Software-defined pulse orchestration platform

ABSTRACT

A system comprises pulse program compiler circuitry operable to analyze a pulse program that includes a pulse operation statement, and to generate, based on the pulse program, machine code that, if loaded into a pulse generation and measurement circuit, configures the pulse generation and measurement circuit to generate one or more pulses and/or process one or more received pulses. The pulse operation statement may specify a first pulse to be generated, and a target of the first pulse. The pulse operation statement may specify parameters to be used for processing of a return signal resulting from transmission of the first pulse. The pulse operation statement may specify an expression to be used for processing of the first pulse by the pulse generation and measurement circuit before the pulse generation and measurement circuit sends the first pulse to the target.

PRIORITY CLAIM

This application is a continuation-in-part of U.S. application Ser. No.17/095,944 filed Nov. 12, 2020, which is a continuation of U.S.application Ser. No. 16/777,480 filed Jan. 30, 2020 (U.S. Pat. No.10,958,253), which claims priority to U.S. provisional patentapplication 62/894,905 filed Sep. 2, 2019, now expired. Theaforementioned applications are hereby incorporated herein by referencein their entirety.

BACKGROUND

Limitations and disadvantages of conventional approaches to pulsegeneration systems will become apparent to one of skill in the art,through comparison of such approaches with some aspects of the presentmethod and system set forth in the remainder of this disclosure withreference to the drawings.

BRIEF SUMMARY

Methods and systems are provided for a software-defined pulseorchestration platform, substantially as illustrated by and/or describedin connection with at least one of the figures, as set forth morecompletely in the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an example pulse orchestration platform.

FIGS. 2A and 2B compare some aspects of classical (binary) computing andquantum computing.

FIG. 2C shows an example use of the pulse orchestration platform forcontrolling a quantum system.

FIG. 3A shows an example quantum orchestration platform (QOP)architecture in accordance with various example implementations of thisdisclosure.

FIG. 3B shows an example implementation of the quantum controllercircuitry of FIG. 3A.

FIG. 4 shows an example implementation of the pulser of FIG. 3B.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B.

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B.

FIG. 6B shows example components of the control signal IF_(l) of FIG.6A.

FIG. 7 shows an example implementation of the digital manager of FIG.3B.

FIG. 8 shows an example implementation of the digital manager of FIG.3B.

FIG. 9A illustrates configuration and control of the quantum controllervia the quantum programming subsystem.

FIG. 9B illustrates an example implementation of the compiler of FIG.9A.

FIGS. 10A-10C show an example quantum machine specification.

FIG. 11 is a flow chart showing an example operation of the QOP.

FIG. 12A shows a portion of a quantum machine configured to perform aPower Rabi calibration.

FIG. 12B shows the result of a Power Rabi calibration.

FIGS. 13A and 13B illustrate the modular and reconfigurable nature ofthe QOP.

DETAILED DESCRIPTION

FIG. 1 shows a pulse orchestration platform. The system comprises aprogramming subsystem 252, a pulse controller 260, and a pulse target258.

The programming subsystem 252 comprises circuitry operable to generatepulse program description 256 which configures the pulse controller 260and includes instructions the pulse controller 260 can execute to carryout the pulse program (i.e., generate the necessary outbound pulse(s)253, process feedback generated in response to the pulse(s) and receivedvia channel 208, and/or process inbound pulses 215) with little or nohuman intervention during runtime. In an example implementation, theprogramming subsystem 252 is a personal computer comprising a processor,memory, and other associated circuitry (e.g., an x86 or x64 chipset)having installed on it a pulse orchestration software development kit(SDK) that enables creation (e.g., by a user via a text editor,integrated development environment (IDE), and/or by automated pulseprogram description generation circuitry) of a high-level (as opposed tobinary or “machine code”) pulse program description 256. In an exampleimplementation, the high-level pulse program description uses ahigh-level programming language (e.g., Python, R, Java, Matlab, etc.)simply as a “host” programming language in which are embedded theprogramming constructs for generating the pulse program description tobe loaded into pulse controller 260.

The high-level pulse program description 256 may comprise aspecification (an example of which is shown in FIGS. 10A-10C) and aprogram (an example program for a Power Rabi calibration is discussedbelow). Although the specification and program may be part of one ormore larger databases and/or contained in one or more files, and one ormore formats, the remainder of this disclosure will, for simplicity ofdescription, assume the configuration data structure and the programdata structure each takes the form of a plain-text file recognizable byan operating system (e.g., windows, Linux, Mac, or another OS) on whichprogramming subsystem 252 runs. The programming subsystem 252 thencompiles the high-level pulse program description 256 to a machine codeversion of the pulse program description 256 (i.e., series of binaryvectors that represent instructions that the hardware of the pulsecontroller 260 can interpret and execute directly).

The programming subsystem 252 communicates with the pulse controller 260using, for example, utilize universal serial bus (USB), peripheralcomponent interconnect (PCIe) bus, wired or wireless Ethernet, or anyother suitable communication protocol. The pulse controller 260comprises circuitry operable to load the machine code pulse programdescription 256 from the programming subsystem 252. Then, execution ofthe machine code by the pulse controller 260 causes the pulse controller260 to generate the corresponding outbound pulse(s) 213 and/or processreturn pulses 215. Depending on the pulse program to be performed,characteristics of generated outbound pulse(s) 213, and/or of processingto be performed on return pulses 215, may be predetermined at designtime and/or may be determined during runtime. The runtime determinationof the outbound pulses characteristics and/or inbound pulse processingmay comprise performance of calculations and processing in the pulsecontroller 260 and/or the programing subsystem 252 during runtime of thepulse program (e.g., runtime analysis of inbound pulses 215 and/orfeedback/results information received from the pulse target 258).

During runtime and/or upon completion of a pulse program performed bythe pulse controller 260, the pulse controller 260 may outputdata/results 208 to the programming subsystem 252. In an exampleimplementation, these results may be used to generate a new pulseprogram description 256 for a subsequent run of the pulse program and/orupdate the pulse program description during runtime.

The pulse controller 260 may comprise a plurality of interconnected, butphysically distinct pulse control modules (e.g., each module being adesktop or rack mounted device) such that pulse control systemsrequiring relatively fewer resources can be realized with relativelyfewer pulse control modules, and pulse control systems requiringrelatively more resources can be realized with relatively more pulsecontrol modules.

The target 258 can be any system with which it is desired to interactvia one or more pulses. One example is where the pulse target 258 is aquantum processor. But of course there are many other types of systemswhere generation and processing of pulses, as enabled by the programmingsubsystem 252 and pulse controller 260, is advantageous.

Another example is where the pulses 213 are radar pulses, the returnpulses 215 are reflections of the pulses 213, and the target 258 is anobject or environment to be characterized based on characteristics ofreflections 215.

Another example is where the pulse target 258 is a device or a systemwhose response to a pulse or series of pulses is to be tested. Forexample, the pulse target 258 may be a wired, wireless, or opticalreceiver and it is desired to test the receiver's response/performancefor various pulses or pulse sequences (e.g., the pulses could berepresentative of desired signals and/or undesired interferers thereceiver may encounter in operation). In this case, the results/feedbackchannel 208 may provide (to the programming subsystem 252 and/or pulsecontroller 260) information about the response/performance of the pulsetarget 258 to the pulse(s) 213, and further pulses/testing may take suchfeedback into account.

For clarity of description, the quantum computing use case is the oneprimarily used in the remainder of this disclosure. But the use ofquantum-specific terminology does not limit the applicability of theconcepts described in this disclosure to other use cases such as theradar and device test use cases described above. For example, referencesto “a quantum element” could be replaced with references to “a target,”references to a “quantum machine specification” could be replaced with“machine specification,” references to a “quantum controller” could bereplaced with references to a “pulse controller”, references to “aquantum programming subsystem” could be replaced with references to a“programming subsystem,” and so on.

Classical computers operate by storing information in the form of binarydigits (“bits”) and processing those bits via binary logic gates. At anygiven time, each bit takes on only one of two discrete values: 0 (or“off”) and 1 (or “on”). The logical operations performed by the binarylogic gates are defined by Boolean algebra and circuit behavior isgoverned by classical physics. In a modern classical system, thecircuits for storing the bits and realizing the logical operations areusually made from electrical wires that can carry two differentvoltages, representing the 0 and 1 of the bit, and transistor-basedlogic gates that perform the Boolean logic operations.

Shown in FIG. 2A is a simple example of a classical computer configuredto a bit 102 and apply a single logic operation 104 to the bit 102. Attime t0 the bit 102 is in a first state, at time t1 the logic operation104 is applied to the bit 102, and at time t2 the bit 102 is in a secondstate determined by the state at time t0 and the logic operation. So,for example, the bit 102 may typically be stored as a voltage (e.g., 1Vdc for a “1” or 0 Vdc for a “0”) which is applied to an input of thelogic operation 104 (comprised of one or more transistors). The outputof the logic gate is then either 1 Vdc or 0 Vdc, depending on the logicoperation performed.

Obviously, a classical computer with a single bit and single logic gateis of limited use, which is why modern classical computers with evenmodest computation power contain billions of bits and transistors. Thatis to say, classical computers that can solve increasingly complexproblems inevitably require increasingly large numbers of bits andtransistors and/or increasingly long amounts of time for carrying outthe algorithms. There are, however, some problems which would require aninfeasibly large number of transistors and/or infeasibly long amount oftime to arrive at a solution. Such problems are referred to asintractable.

Quantum computers operate by storing information in the form of quantumbits (“qubits”) and processing those qubits via quantum gates. Unlike abit which can only be in one state (either 0 or 1) at any given time, aqubit can be in a superposition of the two states at the same time. Moreprecisely, a quantum bit is a system whose state lives in a twodimensional Hilbert space and is therefore described as a linearcombination α|0

+β|1

, where |0

and |1

are two basis states, and a and β are complex numbers, usually calledprobability amplitudes, which satisfy |α|²+|β|²=1. Using this notation,when the qubit is measured, it will be 0 with probability |α|² and willbe 1 with probability |β|²·|0

and |1

can also be represented by two-dimensional basis vectors

${\begin{bmatrix}1 \\0\end{bmatrix}\mspace{14mu}{{and}\mspace{14mu}\begin{bmatrix}0 \\1\end{bmatrix}}},$

respectively, and then the qubit state is represented by

$\begin{bmatrix}\alpha \\\beta\end{bmatrix}.$

The operations performed by the quantum gates are defined by linearalgebra over Hilbert space and circuit behavior is governed by quantumphysics. This extra richness in the mathematical behavior of qubits andthe operations on them, enables quantum computers to solve some problemsmuch faster than classical computers (in fact some problems that areintractable for classical computers may become trivial for quantumcomputers).

Shown in FIG. 2B is a simple example of a quantum computer configured tostore a qubit 122 and apply a single quantum gate operation 124 to thequbit 122. At time t0 the qubit 122 is described by α₁|0

+β₁|1

, at time t1 the logic operation 104 is applied to the qubit 122, and attime t2 the qubits 122 is described by α₂|0

+β₂|1

.

Unlike a classical bit, a qubit cannot be stored as a single voltagevalue on a wire. Instead, a qubit is physically realized using atwo-level quantum mechanical system. Many physical implementations ofqubits have been proposed and developed over the years with some beingmore promising than others. Some examples of leading qubitsimplementations include superconducting circuits, spin qubits, andtrapped ions.

It is the job of the quantum controller to generate the precise seriesof external signals, usually pulses of electromagnetic waves and pulsesof base band voltage, to perform the desired logic operations (and thuscarry out the desired quantum algorithm). Example implementations of aquantum controller are described in further detail below.

FIG. 2C shows an example use of the pulse orchestration platform forcontrolling a quantum system. For this implementation, the system willbe referred to as a quantum orchestration platform (QOP), the quantumprogramming subsystem 202 corresponds to the programming subsystem 252of FIG. 1, the quantum controller 210 corresponds to the pulsecontroller 210 of FIG. 1, and the quantum processor 218 corresponds tothe target 258 of FIG. 1.

The quantum programming subsystem 202 comprises circuitry operable togenerate a pulse program description 206 which configures the quantumcontroller 210 and includes instructions the quantum controller 210 canexecute to carry out the quantum algorithm (i.e., generate the necessaryoutbound quantum control pulse(s) 213) with little or no humanintervention during runtime.

The quantum programming subsystem 202 is coupled to the quantumcontroller 210 via interconnect 204 which may, for example, utilizeuniversal serial bus (USB), peripheral component interconnect (PCIe)bus, wired or wireless Ethernet, or any other suitable communicationprotocol. The quantum controller 210 comprises circuitry operable toload the machine code pulse program description 206 from the programmingsubsystem 202 via interconnect 204. Then, execution of the machine codeby the quantum controller 210 causes the quantum controller 210 togenerate the necessary outbound quantum control pulse(s) 213 thatcorrespond to the desired operations to be performed on the quantumprocessor 218 (e.g., sent to qubit(s) for manipulating a state of thequbit(s) or to readout resonator(s) for reading the state of thequbit(s), etc.). Depending on the quantum algorithm to be performed,outbound pulse(s) 213 for carrying out the algorithm may bepredetermined at design time and/or may need to be determined duringruntime. The runtime determination of the pulses may compriseperformance of classical calculations and processing in the quantumcontroller 210 and/or the quantum programing subsystem 202 duringruntime of the algorithm (e.g., runtime analysis of inbound pulses 215received from the quantum processor 218).

The quantum controller 210 is coupled to the quantum processor 218 viainterconnect 212 which may comprise, for example, one or more conductorsand/or optical fibers. The quantum controller 210 may comprise aplurality of interconnected, but physically distinct quantum controlmodules (e.g., each module being a desktop or rack mounted device) suchthat quantum control systems requiring relatively fewer resources can berealized with relatively fewer quantum control modules and quantumcontrol systems requiring relatively more resources can be realized withrelatively more quantum control modules.

The quantum processor 218 comprises K (an integer) quantum elements 122,which includes qubits (which could be of any type such assuperconducting, spin qubits, ion trapped, etc.), and, where applicable,any other element(s) for processing quantum information, storing quantuminformation (e.g. storage resonator), and/or coupling the outboundquantum control pulses 213 and inbound quantum control pulses 215between interconnect 212 and the quantum element(s) 122 (e.g., readoutresonator(s)). In an example implementation in which the quantumprocessor comprises readout resonators (or other readout circuitry), Kmay be equal to the total number of qubits plus the number of readoutcircuits. That is, if each of Q (an integer) qubits of the quantumprocessor 218 is associated with a dedicated readout circuit, then K maybe equal to 2Q. For ease of description, the remainder of thisdisclosure will assume such an implementation, but it need not be thecase in all implementations. Other elements of the quantum processor 218may include, for example, flux lines (electronic lines for carryingcurrent), gate electrodes (electrodes for voltage gating),current/voltage lines, amplifiers, classical logic circuits residingon-chip in the quantum processor 218, and/or the like.

FIG. 3A shows an example quantum controller architecture in accordancewith various example implementations of this disclosure. The quantumcontroller 210 comprises L (an integer≥1) pulser circuits 302 ₀-302_(L−1) and shared circuitry 310.

In the example implementation shown, each pulser circuit 302 _(l) (I aninteger between 0 and L−1) comprises circuitry for exchanginginformation over signal paths 304 _(l), 306 _(l), and 308 _(l), wherethe signal path 308 _(l) carries outbound pulses (e.g., 213 of FIG. 2C)generated by the pulser circuit 302 _(l) (which may be, for example,control pulses sent to the quantum processor 218 to manipulate one ormore properties of one or more quantum elements—e.g., manipulate a stateof one or more qubits, manipulate a frequency of a qubit using fluxbiasing, etc., and/or readout a state of one or more quantum elements),the signal path 306 _(l) carries inbound quantum element readout pulses(e.g., 215 of FIG. 2C) to be processed by the pulser circuit 302 _(l),and signal path 304 _(l) carries control information. Each signal pathmay comprise one or more conductors, optical channels, and/or wirelesschannels.

Each pulser circuit 302 _(l) comprises circuitry operable to generateoutbound pulses on signal path 308 _(l) according to quantum controloperations to be performed on the quantum processor 218. This involvesvery precisely controlling characteristics such as phase, frequency,amplitude, slope, chirp rate, duration, and/or timing of the outboundpulses. The characteristics of an outbound pulse generated at anyparticular time may be determined, at least in part, on inbound pulsesreceived from the quantum processor 218 (via shared circuitry 310 andsignal path 306 _(l)) at a prior time. In an example implementation, thetime required to close the feedback loop (i.e., time from receiving afirst pulse on one or more of paths 315 ₁-315 _(L) (e.g., at an analogto digital converter of the path) to sending a second pulse on one ormore of paths 313 ₀-313 _(L−1) (e.g., at an output of adigital-to-analog converter of the path), where the second pulse isbased on the first pulse, is significantly less than the coherence timeof the qubits of the quantum processor 218. For example, the time toclose the feedback loop may be on the order of 100 nanoseconds. Itshould be noted that each signal path in FIG. 3A may in practice be aset of signal paths for supporting generation of multi-pulse sets (e.g.,two signal paths for two-pulse pairs, three signal paths for three-pulsesets, and so on).

In the example implementation shown, the shared circuitry 310 comprisescircuitry for exchanging information with the pulser circuits 302 ₀-302_(L−1) over signal paths 304 ₀-304 _(K−1), 306 ₀-306 _(L−1), and 308₀-308 _(L−1), where each signal path 308 _(l) carries outbound pulsesgenerated by the pulser circuit 302 _(l), each signal path 306 _(l)carries inbound pulses to be processed by pulser circuit 302 _(l), andeach signal path 304 _(l) carries control information such asflag/status signals, data read from memory, data to be stored in memory,data streamed to/from the quantum programming subsystem 202, and data tobe exchanged between two or more pulsers 302 ₀-302 _(L). Similarly, inthe example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum processor 218 over signal paths315 ₀-315 _(M−1) and 313 ₁-313 _(K−1), where each signal path 315 _(m)(m an integer between 0 and M−1) carries inbound pulses from the quantumprocessor 218, and each signal path 313 _(k) (k an integer between 0 andK−1) carries outbound pulses to the quantum processor 218. Additionally,in the example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum programming subsystem oversignal path 311. The shared circuitry 310 may be: integrated with thequantum controller 210 (e.g., residing on one or more of the same fieldprogrammable gate arrays or application specific integrated circuits orprinted circuit boards); external to the quantum controller (e.g., on aseparate FPGA, ASIC, or PCB connected to the quantum controller via oneor more cables, backplanes, or other devices connected to the quantumprocessor 218, etc.); or partially integrated with the quantumcontroller 210 and partially external to the quantum controller 210.

In various implementations, M may be less than, equal to, or greaterthan L, K may be less than, equal to, or greater than L, and M may beless than, equal to, or greater than K. For example, the nature of somequantum algorithms is such that not all K quantum elements need to bedriven at the same time. For such algorithms, L may be less than K andone or more of the L pulsers 302 _(l) may be shared among multiple ofthe K quantum elements circuits. That is, any pulser 302 _(l) maygenerate pulses for different quantum elements at different times. Thisability of a pulser 302 _(l) to generate pulses for different quantumelements at different times can reduce the number of pulsers 302 ₀-302_(L−1) (i.e., reduce L) required to support a given number of quantumelements (thus saving significant resources, cost, size, overhead whenscaling to larger numbers of qubits, etc.).

The ability of a pulser 302 _(l) to generate pulses for differentquantum elements at different times also enables reduced latency. Asjust one example, assume a quantum algorithm which needs to send a pulseto quantum element 122 ₀ at time T1, but whether the pulse is to be of afirst type or second type (e.g., either an X pulse or a Hadamard pulse)cannot be determined until after processing an inbound readout pulse attime T1-DT (i.e., DT time intervals before the pulse is to be output).If there were a fixed assignment of pulsers 302 ₀-302 _(L−1) to quantumelements of the quantum processor 218 (i.e., if 302 ₀ could only sendpulses to quantum element 122 ₀, and pulser 302 ₁ could only send pulsesto quantum element 122 ₁, and so on), then pulser 302 ₀ might not beable to start generating the pulse until it determined what the type wasto be. In the depicted example implementation, on the other hand, pulser302 ₀ can start generating the first type pulse and pulser 302 ₁ canstart generating the second type pulse and then either of the two pulsescan be released as soon as the necessary type is determined. Thus, ifthe time to generate the pulse is T_(lat), in this example the examplequantum controller 210 may reduce latency of outputting the pulse byT_(lat).

The shared circuitry 310 is thus operable to receive pulses via any oneor more of the signals paths 308 ₀-308 _(L−1) and/or 315 ₀-315 _(M−1),process the received pulses as necessary for carrying out a quantumalgorithm, and then output the resulting processed pulses via any one ormore of the signal paths 306 ₀-306 _(L−1) and/or 313 ₀-313 _(K−4). Theprocessing of the pulses may take place in the digital domain and/or theanalog domain. The processing may comprise, for example: frequencytranslation/modulation, phase translation/modulation, frequency and/ortime division multiplexing, time and/or frequency divisiondemultiplexing, amplification, attenuation, filtering in the frequencydomain and/or time domain, time-to-frequency-domain orfrequency-to-time-domain conversion, upsampling, downsampling, and/orany other signal processing operation. At any given time, the decisionas to from which signal path(s) to receive one or more pulse(s), and thedecision as to onto which signal path(s) to output the pulse(s) may be:predetermined (at least in part) in the pulse program description 206;and/or dynamically determined (at least in part) during runtime of thepulse program based on classical programs/computations performed duringruntime, which may involve processing of inbound pulses. As an exampleof predetermined pulse generation and routing, a pulse programdescription 206 may simply specify that a particular pulse withpredetermined characteristics is to be sent to signal path 313 ₁ at apredetermined time. As an example of dynamic pulse determination androuting, a pulse program description 206 may specify that an inboundreadout pulse at time T-DT should be analyzed and its characteristics(e.g., phase, frequency, and/or amplitude) used to determine, forexample, whether at time T pulser 302 _(l) should output a pulse to afirst quantum element or to a second quantum element or to determine,for example, whether at time T pulser 302 _(l) should output a firstpulse to a first quantum element or a second pulse to the first quantumelement. In various implementations of the quantum controller 210, theshared circuitry 310 may perform various other functions instead ofand/or in addition to those described above. In general, the sharedcircuitry 310 may perform functions that are desired to be performedoutside of the individual pulser circuits 302 ₀-302 _(L−1). For example,a function may be desirable to implement in the shared circuitry 310where the same function is needed by a number of pulser circuits from302 ₀-302 _(L−1) and thus may be shared among these pulser circuitsinstead of redundantly being implemented inside each pulser circuit. Asanother example, a function may be desirable to implement in the sharedcircuitry 310 where the function is not needed by all pulser circuits302 ₀-302 _(L−1) at the same time and/or on the same frequency and thusfewer than L circuits for implementing the function may be shared amongthe L pulser circuits 302 ₀-302 _(L−1) through time and/or frequencydivision multiplexing. As another example, a function may be desirableto implement in the shared circuitry 310 where the function involvesmaking decisions based on inputs, outputs, and/or state of multiple ofthe L pulser circuits 302 ₀-302 _(L−1), or other circuits. Utilizing acentralized coordinator/decision maker in the shared circuitry 310 mayhave the benefit(s) of: (1) reducing pinout and complexity of the pulsercircuits 302 ₀-302 _(L−1); and/or (2) reducing decision-making latency.Nevertheless, in some implementations, decisions affecting multiplepulser circuits 302 ₀-302 _(L−1) may be made by one or more of thepulser circuits 302 ₀-302 _(L−1) where the information necessary formaking the decision can be communicated among pulser circuits within asuitable time frame (e.g., still allowing the feedback loop to be closedwithin the qubit coherence time) over a tolerable number of pins/traces.

FIG. 3B shows an example implementation of the quantum controller ofFIG. 2C. The example quantum controller shown comprises pulsers 302₁-302 _(L−1), receive analog frontend 350, input manager 352, digitalmanager 354, pulse operations manager 356, pulse operations 358, outputmanager 360, transmit analog frontend 362, data exchange 364,synchronization manager 366, and input/output (“I/O”) manager 368.Circuitry depicted in FIG. 3B other than pulser circuits 302 ₀-302_(L−1) corresponds to an example implementation of the shared circuitry310 of FIG. 3A.

The receive analog frontend 350 comprises circuitry operable toconcurrently process up to M (an integer≥1) analog inbound signals(RP′₀-RP_(M−1)) received via signal paths 315 ₀-315 _(M−1) to generateup to M concurrent inbound signals (RP₀-RP_(M−1)) to be output to inputmanager 352 via one or more signal paths. Although there is shown to beM signals RP and M signals RP′, this need not be the case. Suchprocessing may comprise, for example, analog-to-digital conversion,filtering, upconversion, downconversion, amplification, attenuation,time division multiplexing/demultiplexing, frequency divisionmultiplexing/demultiplexing, and/or the like. In variousimplementations, M may be less than, equal to, or greater than L and Mmay be less than, equal to, or greater than K.

The input manager 352 comprises circuitry operable to route any one ormore of signals (RP₀-RP_(M−1)) to any one or more of pulsers 302 ₀-302_(L−1) (as signal(s) AI₀-AI_(L−1)) and/or to other circuits (e.g. assignal io_mgr to I/O manager 368). In an example implementation, theinput manager 352 comprises one or more switch networks, multiplexers,and/or the like for dynamically reconfiguring which signals RP₀-RP_(M−1)are routed to which pulsers 302 ₀-302 _(L−1). This may enable timedivision multiplexing multiple of the signals RP₀-RP_(M−1) onto a singlesignal AI_(l) and/or time division demultiplexing components (e.g., timeslices) of a signal RP_(m) onto multiple of the signals AI₀-AI_(L−1). Inan example implementation, the input manager 352 comprises one or moremixers and/or filters for frequency division multiplexing multiple ofthe signals RP₀-RP_(M−1) onto a single signal AI_(l) and/or frequencydivision demultiplexing components (e.g., frequency bands) of a signalRP_(m) onto multiple of the signals AI₀-AI_(L−1). The signal routing andmultiplexing/demultiplexing functions performed by the input manager 352enables: a particular pulser 302 _(l) to process different inboundpulses from different quantum elements at different times; a particularpulser 302 _(l) to process different inbound pulses from differentquantum elements at the same time; and multiple of the pulsers 302 ₀-302_(L−1) to processes the same inbound pulse at the same time. In theexample implementation shown, routing of the signals RP₀-RP_(M−1) amongthe inputs of the pulsers 302 ₀-302 _(L−1) is controlled by digitalcontrol signals in_slct₀-in_slct_(L−1) from the pulsers 302 ₀-302_(L−1). In another implementation, the input manager may be operable toautonomously determine the appropriate routing (e.g., where the pulseprogram description 206 includes instructions to be loaded into memoryof, and executed by, the input manager 352). In the exampleimplementation, the input manager 352 is operable to rout input signalsRP₀-RP_(M−1) to the I/O manager 368 (as signal(s) io_mgr), to be sent tothe quantum programing subsystem 202. This routing may, for example, becontrolled by signals from the digital manager 354. In an exampleimplementation, for each input signal RP_(m) there is a digital signal,stream_(m), from the digital manager 354 to the input manager 352 thatcontrols whether RP_(m) will be sent from the input manager 352 to theI/O manager 368 and from there to the quantum programing subsystem 202.

Each of the pulsers 302 ₀-302 _(L−1) is as described above withreference to FIG. 3A. In the example implementation shown, each pulser302 _(l) is operable to generate raw outbound pulses CP′_(l) (“raw” isused simply to denote that the pulse has not yet been processed by pulseoperations circuitry 358) and digital control signals in_slct_(l),D_port_(l), D_(l), out_slct_(l), ops_ctrl_(l), ops_slct_(l), IF_(l),F_(l), and dmod_sclt_(l) for carrying out quantum algorithms on thequantum processor 218, and results_(l) for carrying intermediate and/orfinal results generated by the pulser 302 _(l) to the quantumprogramming subsystem 202. One or more of the pulsers 302 ₀-302 _(L−1)may receive and/or generate additional signals which are not shown inFIG. 3A for clarity of illustration. The raw outbound pulsesCP′₀-CP′_(L−1) are conveyed via signal paths 308 ₀-308 _(L−1) and thedigital control signals are conveyed via signal paths 304 ₀-304 _(L−1).Each of the pulsers 302 _(l) is operable to receive inbound pulse signalAI_(l) and signal f_dmod_(l). Pulser 302 _(l) may process the inboundsignal AI_(l) to determine the state of certain quantum element(s) inthe quantum processor 218 and use this state information for makingdecisions such as, for example, which raw outbound pulse CP′_(l) togenerate next, when to generate it, and what control signals to generateto affect the characteristics of that raw outbound pulse appropriately.Pulser 302 _(l) may use the signal f_dmod_(l) for determining how toprocess inbound pulse signal AI_(l). As an example, when pulser 302 ₁needs to process an inbound signal AI_(l) from quantum element 122 ₃, itcan send a dmod_sclt₁ signal that directs pulse operations manager 356to send, on f_dmod₁, settings to be used for demodulation of an inboundsignal AI₁ from quantum element 122 ₃ (e.g., the pulse operationsmanager 356 may send the value cos(ω₃*TS*T_(clk1)+ϕ₃), where ω₃ is thefrequency of quantum element 122 ₃, TS is amount of time passed sincethe reference point, for instance the time at which a pulse programstarted running, and ϕ₃ is the phase of the total frame rotation ofquantum element 122 ₃, i.e. the accumulated phase of all frame rotationssince the reference point).

The pulse operations circuitry 358 is operable to process the rawoutbound pulses CP′₀-CP′_(L−1) to generate corresponding output outboundpulses CP₀-CP_(L−1). This may comprise, for example, manipulating theamplitude, phase, duration, chirp rate, slope, and/or frequency of theraw pulse CP′_(l). The pulse operations circuitry 358 receives rawoutbound pulses CP′₀-CP′_(L−1) from pulsers 302 ₀-302 _(L−1), controlsignals ops_cnfg₀-ops_cnfg_(L−1) from pulse operations manager 356, andops_ctrl₀-ops_ctrl_(L−1) from pulsers 302 ₀-302 _(L−1).

The control signal ops_cnfg_(l) configures, at least in part, the pulseoperations circuitry 358 such that each raw outbound pulse CP′_(l) thatpasses through the pulse operations circuitry 358 has performed on itone or more operation(s) tailored for that particular pulse. Toillustrate, denoting a raw outbound pulse from pulser 302 ₃ at time T1as CP′_(3,T1), then, at time T1 (or sometime before T1 to allow forlatency, circuit setup, etc.), the digital control signal ops_cnfg₃(denoted ops_cnfg_(3,T1) for purposes of this example) provides theinformation (e.g., in the form of one or more matrix, as describedbelow) as to what specific operations are to be performed on pulseCP′_(3,T1). Similarly, ops_cnfg_(4,T1) provides the information as towhat specific operations are to be performed on pulse CP′_(4,T1), andops_cnfg_(3,T2) provides the information as to what specific operationsare to be performed on pulse CP′4,T1.

The control signal ops_ctrl_(l) provides another way for the pulser 302_(l) to configure how any particular pulse is processed in the pulseoperations circuitry 358. This may enable the pulser 302 _(l) to, forexample, provide information to the pulse operation circuitry 358 thatdoes not need to pass through the pulse operation manager 356. Forexample, the pulser 302 _(l) may send matrix values calculated inreal-time by the pulser 302 _(l) to be used by the pulse operationcircuitry 358 to modify pulse CP′_(l). These matrix values arrive to thepulse operation circuitry 358 directly from the pulser 302 _(l) and donot need to be sent to the pulse operation manager first. Anotherexample may be that the pulser 302 _(l) provides information to thepulse operation circuitry 358 to affect the operations themselves (e.g.the signal ops_ctrl_(l) can choose among several different mathematicaloperations that can be performed on the pulse).

The pulse operations manager 356 comprises circuitry operable toconfigure the pulse operations circuitry 358 such that the pulseoperations applied to each raw outbound pulse CP′_(l) are tailored tothat particular raw outbound pulse. To illustrate, denoting a first rawoutbound pulse to be output during a first time interval T1 asCP′_(l,T1), and a second raw outbound pulse to be output during a secondtime interval T2 as CP′_(l,T2), then pulse operations circuitry 358 isoperable to perform a first one or more operations on CP′_(l,T1) and asecond one or more operations on CP′_(l,T2). The first one or moreoperations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T1) is to be sent, and the second one ormore operations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T2) is to be sent. The determination ofthe first one or more operations and second one or more operations maybe performed dynamically during runtime.

The transmit analog frontend 362 comprises circuitry operable toconcurrently process up to K digital signals DO_(k) to generate up to Kconcurrent analog signals AO_(k) to be output to the quantum processor218. Such processing may comprise, for example, digital-to-analogconversion, filtering, upconversion, downconversion, amplification,attenuation, time division multiplexing/demultiplexing, frequencydivision multiplexing/demultiplexing and/or the like. In an exampleimplementation, each of the one or more of signal paths 313 ₀-313 _(k−1)(FIG. 3A) represents a respective portion of Tx analog frontend circuit362 as well as a respective portion of interconnect 212 (FIG. 2C)between the Tx analog frontend circuit 362 and the quantum processor218. Although there is one-to-one correspondence between the number ofDO signals and the number of AO signals in the example implementationdescribed here, such does not need to be the case. In another exampleimplementation, the analog frontend 362 is operable to map more (orfewer) signals DO to fewer (or more) signals AO. In an exampleimplementation the transmit analog frontend 362 is operable to processdigital signals DO₀-DO_(K−1) as K independent outbound pulses, as K/2two-pulse pairs, or process some of signals DO₀-DO_(K−1) as independentoutbound pulses and some signals DO₀-DO_(K−1) as two-pulse pairs (atdifferent times and/or concurrently.

The output manager 360 comprises circuitry operable to route any one ormore of signals CP₀-CP_(L−1) to any one or more of signal paths 313₀-313 _(K−1). As just one possible example, signal path 313 ₀ maycomprise a first path through the analog frontend 362 (e.g., a firstmixer and DAC) that outputs AO₀ and traces/wires of interconnect 212that carry signal AO₀; signal path 313 ₁ may comprise a second paththrough the analog frontend 362 (e.g., a second mixer and DAC) thatoutputs AO₁ and traces/wires of interconnect 212 that carry signal AO₁,and so on. In an example implementation, the output manager 360comprises one or more switch networks, multiplexers, and/or the like fordynamically reconfiguring which one or more signals CP₀-CP_(L−1) arerouted to which signal paths 313 ₀-313 _(K−1). This may enable timedivision multiplexing multiple of the signals CP₀-CP_(L−1) onto a singlesignal path 313 _(k) and/or time division demultiplexing components(e.g., time slices) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(K−1). In an example implementation, the output manager 360comprises one or more mixers and/or filters for frequency divisionmultiplexing multiple of the signals CP₀-CP_(M−1) onto a single signalpath 313 _(k) and/or frequency division demultiplexing components (e.g.,frequency bands) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(K−1). The signal routing and multiplexing/demultiplexingfunctions performed by the output manager 360 enables: routing outboundpulses from a particular pulser 302 _(l) to different ones of the signalpaths 313 ₀-313 _(K−1) at different times; routing outbound pulses froma particular pulser 302 _(l) to multiple of the signal paths 313 ₀-313_(K−1) at the same time; and multiple of the pulsers 302 ₀-302 _(L−1)generating pulses for the same signal path 313 _(k) at the same time. Inthe example implementation shown, routing of the signals CP₀-CP_(L−1)among the signal paths 313 ₀-313 _(K−1) is controlled by digital controlsignals out_slct₀-out_slct_(L−1) from the pulsers 302 ₀-302 _(L−1). Inanother implementation, the output manager 360 may be operable toautonomously determine the appropriate routing (e.g., where the quantumpulse program description 206 includes instructions to be loaded intomemory of, and executed by, the output manager 360). In an exampleimplementation, at any given time, the output manager 360 is operable toconcurrently route K of the digital signals CP₀-CP_(L−1) as Kindependent outbound pulses, concurrently route K/2 of the digitalsignals CP₀-CP_(L−1) as two-pulse pairs, or route some of signalsCP₀-CP_(L−1) as independent outbound pulses and some others of thesignals CP₀-CP_(L−1) as multi-pulse sets (at different times and/orconcurrently).

The digital manager 354 comprises circuitry operable to process and/orroute digital control signals (DigCtrl₀-DigCtrl_(J−1).) to variouscircuits of the quantum controller 210 and/or external circuits coupledto the quantum controller 210. In the example implementation shown, thedigital manager receives, from each pulser 302 _(l), (e.g., via one ormore of signal paths 304 ₀-304 _(N−1)) a digital signal D_(l) that is tobe processed and routed by the digital manager 354, and a control signalD_port_(l) that indicates to which output port(s) of the digital manager354 the signal D_(l) should be routed. The digital control signals maybe routed to, for example, any one or more of circuits shown in FIG. 3B,switches/gates which connect and disconnect the outputs A0 ₀-A0 _(K−1)from the quantum processor 218, external circuits coupled to the quantumcontroller 210 such as microwave mixers and amplifiers, and/or any othercircuitry which can benefit from on real-time information from thepulser circuits 302 ₀-302 _(L−1). Each such destination of the digitalsignals may require different operations to be performed on the digitalsignal (such as delay, broadening, or digital convolution with a givendigital pattern). These operations may be performed by the digitalmanager 354 and may be specified by control signals from the pulsers 302₀-302 _(L−1). This allows each pulser 302 _(l) to generate digitalsignals to different destinations and allows different ones of pulsers302 ₀-302 _(L−1) to generate digital signals to the same destinationwhile saving resources.

The synchronization manager 366 comprises circuitry operable to managesynchronization of the various circuits shown in FIG. 3B. Suchsynchronization is advantageous in a modular and dynamic system, such asquantum controller 210, where different ones of pulsers 302 ₀-302 _(L−1)generate, receive, and process pulses to and from different quantumelements at different times. For example, while carrying out a quantumalgorithm, a first pulser circuit 302 _(l) and a second pulser circuit302 ₂ may sometimes need to transmit pulses at precisely the same timeand at other times transmit pulses independently of one another. In theexample implementation shown, the synchronization manager 366 reducesthe overhead involved in performing such synchronization.

The data exchange circuitry 364 is operable to manage exchange of dataamong the various circuits shown in FIG. 3B. For example, while carryingout a quantum algorithm, a first pulser circuit 302 ₁ and a secondpulser circuit 302 ₂ may sometimes need to exchange information. As justone example, pulser 302 ₁ may need to share, with pulser 302 ₂, thecharacteristics of an inbound signal AI_(l) that it just processed sothat pulser 302 ₂ can generate a raw outbound pulse CP′₂ based on thecharacteristics of AI₁. The data exchange circuitry 364 may enable suchinformation exchange. In an example implementation, the data exchangecircuitry 364 may comprise one or more registers to and from which thepulsers 302 ₀-302 _(L−1) can read and write.

The I/O manager 368 is operable to route information between the quantumcontroller 210 and the quantum programming subsystem 202. Machine codequantum pulse program descriptions may be received via the I/O manager368. Accordingly, the I/O manager 368 may comprise circuitry for loadingthe machine code into the necessary registers/memory (including anySRAM, DRAM, FPGA BRAM, flash memory, programmable read only memory,etc.) of the quantum controller 210 as well as for reading contents ofthe registers/memory of the quantum controller 210 and conveying thecontents to the quantum programming subsystem 202. The I/O manager 368may, for example, include a PCIe controller, AXIcontroller/interconnect, and/or the like. In an example implementation,the I/O manager 368 comprises one or more registers 380 which can bewritten to and read from via a quantum machine API (an example of whichis shown below in Table 6) and via reserved variables in the languageused to create pulse program description 206.

FIG. 4 shows an example implementation of the pulser of FIG. 3B. Theexample pulser 302 _(l) shown comprises instruction memory 402, pulsetemplate memory 404, digital pattern memory 406, control circuitry 408,and compute and/or signal processing circuitry (CSP) 410.

The memories 402, 404, 406 may comprise one or more be any type ofsuitable storage elements (e.g., DRAM, SRAM, Flash, etc.). Theinstructions stored in memory 402 are instructions to be executed out bythe pulser 302 _(l) for carrying out its role in a quantum algorithm.Because different pulsers 302 ₀-302 _(L−1) have different roles to playin any particular quantum algorithm (e.g., generating different pulsesat different times), the instructions memory 402 for each pulser 302_(l) may be specific to that pulser. For example, the pulse programdescription 206 from the quantum programming subsystem 202 may comprisea first set of instructions to be loaded (via I/O manager 368) intopulser 302 ₀, a second set of instructions to be loaded into pulser 302₁, and so on. Each pulse template stored in memory 404 comprises asequence of one or more samples of any arbitrary shape (e.g., Gaussian,sinc, impulse, etc.) representing the pulses to be sent to pulseoperation circuitry 358. Each digital pattern stored in memory 406comprises a sequence of one or more binary values which may representthe digital pulses to be sent to the digital manager 354 for generatingdigital control signals DigCtrl₀-DigCtrl_(J−1).

The control circuitry 408 is operable to execute the instructions storedin memory 402 to process inbound signal AI_(l), generate raw outboundpulses CP′_(l), and generate digital control signals in_slct_(l),out_slct_(l), D_port_(l), D_(l), IF_(l), F_(l), ops_slct_(l),ops_ctrl_(l), results_(l), dmod_slct_(l) and pair_(l). In the exampleimplementation shown, the processing of the inbound signal AI_(l) isperformed by the CSP circuitry 410 and based (at least in part) on thesignal f_dmod_(l).

The compute and/or signal processing circuitry (CSP) 410 is operable toperform computational and/or signal processing functions, which maycomprise, for example Boolean-algebra based logic and arithmeticfunctions and demodulation (e.g., of inbound signals AI_(l)). The CSP410 may comprise memory in which are stored instructions for performingthe functions and demodulation. The instructions may be specific to aquantum algorithm to be performed and be generated during compilation ofa quantum machine specification and QUA program.

In operation of an example implementation, generation of a raw outboundpulse CP′_(l) comprises the control circuitry 408: (1) determining apulse template to retrieve from memory 404 (e.g., based on a result ofcomputations and/or signal processing performed by the CSP 410); (2)retrieving the pulse template; (3) performing some preliminaryprocessing on the pulse template; (4) determining the values of F, IF,pair_(l), ops_slct_(l), and dmod_slct_(l) to be sent to the pulseoperation manager 356 (as predetermined in the pulse program description206 and/or determined dynamically based on results of computationsand/or signal processing performed by the CSP 410); (5) determining thevalue of ops_ctrl_(l) to be sent to the pulse operation circuitry 358;(6) determining the value of in_slct_(l) to be sent to the input manager352; (7) determining a digital pattern to retrieve from memory 406 (aspredetermined in the pulse program description 206 and/or determineddynamically based on results of computations and/or signal processingperformed by the CSP 410); (8) outputting the digital pattern as D_(l)to the digital manager along with control signal D_port_(l) (aspredetermined in the pulse program description and/or determineddynamically based on results of computations and/or signal processingperformed by the CSP 410); (9) outputting the raw outbound pulse CP′_(l)to the pulse operations circuitry 358; (10) outputting results_(l) tothe I/O manager.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B. The pulse operationscircuitry 358 comprises a plurality of pulse modification circuits 508₀-508 _(R-1) (R is an integer 1 in general, and R=L/2 in the exampleshown). The pulse operations manager 356 comprises control circuitry502, routing circuitry 506, and a plurality of modification settingscircuits 504 ₀-504 _(K−1).

Although the example implementation has a 1-to-2 correspondence betweenpulse modification circuits 508 ₀-508 _(R-1) and pulser circuits 302₀-302 _(L−1), such does not need to be the case. In otherimplementations there may be fewer pulse modification circuits 508 thanpulser circuits 302. Similarly, other implementations may comprise morepulse modification circuits 508 than pulser circuits 302.

As an example, in some instances, two of the pulsers 302 ₀-302 _(L−1)may generate two raw outbound pulses which are a phase-quadrature pulsepair. For example, assuming CP₁ and CP₂ are a phase-quadrature pulsepair to be output on path 313 ₃. In this example, pulse operationscircuitry 358 may process CP₁ and CP₂ by multiplying a vectorrepresentation of CP′₁ and CP′₂ by one or more 2 by 2 matrices to: (1)perform single-sideband-modulation, as given by

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos\;\left( {\omega*TS*T_{clck1}} \right)} & {{- {s{in}}}\;\left( {\omega*TS*T_{clck1}} \right)} \\{\sin\;\left( {\omega*TS*T_{clck1}} \right)} & {\cos\;\left( {\omega*TS*T_{clck1}} \right)}\end{pmatrix}\begin{pmatrix}{C\; P_{1}^{\prime}} \\{C\; P_{2}^{\prime}}\end{pmatrix}}},$

where ω is the frequency of the single side band modulation and TS isthe time passed since the reference time (e.g. the beginning of acertain control protocol); (2) keep track of frame-of-referencerotations, as given by

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos\;(\phi)} & {- {{s{in}}(\phi)}} \\{{s{in}}(\phi)} & {\cos\;(\phi)}\end{pmatrix}\begin{pmatrix}{C\; P_{1}^{\prime}} \\{C\; P_{2}^{\prime}}\end{pmatrix}}},$

where ϕ is the total phase that the frame of reference accumulated sincethe reference time; and/or (3) perform an IQ-mixer correction

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{C\; P_{1}^{\prime}} \\{C\; P_{2}^{\prime}}\end{pmatrix}}},$

where C₀₀, C₀₁, C₁₀, and C₁₁ are the elements of a matrix that correctsfor IQ-mixer imperfections. In an example implementation, eachmodification settings circuit, 504 _(k), contains registers that containthe matrix elements of three matrices:

${C_{k} = \begin{pmatrix}C_{k00} & C_{k01} \\C_{k10} & C_{k11}\end{pmatrix}},$

an IQ-mixer correction matrix;

${s_{k} = \begin{pmatrix}{\cos\;\left( {\omega_{k}*TS*T_{clck1}} \right)} & {{- {s{in}}}\;\left( {\omega_{k}*TS} \right)*T_{clck1}} \\{\sin\;\left( {\omega_{k}*TS*T_{clck1}} \right)} & {\cos\;\left( {\omega_{k}*TS*T_{{clck}\; 1}} \right)}\end{pmatrix}},$

a single side band frequency modulation matrix; and

${F_{k} = \begin{pmatrix}{\cos\;\left( \phi_{k} \right)} & {- {{s{in}}\left( \phi_{k} \right)}} \\{{s{in}}\left( \phi_{k} \right)} & {\cos\;\left( \phi_{k} \right)}\end{pmatrix}},$

a frame rotation matrix, which rotates the IQ axes around the axisperpendicular to the IQ plane (i.e. the z-axis if I and Q are the x-axisand y-axis). In an example implementation, each modification settingscircuit 504 _(k) also contains registers that contain the elements ofthe matrix products C_(k)S_(k)F_(k) and S_(k)F_(k).

In the example shown, each pulse modification circuit 508 _(r) isoperable to process two raw outbound pulses CP′_(2r) and CP′_(2r+1),according to: the modification settings ops_cnfg_(2r) andops_cnfg_(2r+1); the signals ops_ctrl_(2r) and ops_ctrl_(2r+1); and thesignals pair_(2r) and pair_(2r+1). In an example implementationpair_(2r) and pair_(2r+1) may be communicated as ops_ctrl_(2r) andops_ctrl_(2r+1). The result of the processing is outbound pulses CP_(2r)and CP_(2r+1). Such processing may comprise adjusting a phase,frequency, and/or amplitude of the raw outbound pulses CP′_(2r) andCP_(2r+1). In an example implementation, ops_cnfg_(2r) andops_cnfg_(2r+1) are in the form of a matrix comprising real and/orcomplex numbers and the processing comprises matrix multiplicationinvolving a matrix representation of the raw outbound pulses CP_(2r) andCP_(2r+1) and the ops_cnfg_(2r) and ops_cnfg_(2r+1) matrix.

The control circuitry 502 is operable to exchange information with thepulser circuits 302 ₀-302 _(L−1) to generate values ofops_confg₀-ops_confg_(L−1) and f_demod₀-f_demod_(L−1), to controlrouting circuitry 506 based on signals ops_slct₀-ops_slct_(L−1) anddmod_slct₀-dmod_slct_(L−1), and to update pulse modification settings504 ₀-504 _(K−1) based on IF₀-IF_(L−1) and F₀-F_(L−1) such that pulsemodification settings output to pulse operations circuitry 358 arespecifically tailored to each raw outbound pulse (e.g., to which quantumelement 222 the pulse is destined, to which signal path 313 the pulse isdestined, etc.) to be processed by pulse operations circuitry 358.

Each modification settings circuit 504 _(k) comprises circuitry operableto store modification settings for later retrieval and communication tothe pulse operations circuitry 358. The modification settings stored ineach modification settings circuit 504 _(k) may be in the form of one ormore two-dimensional complex-valued matrices. Each signal path 313 ₀-313_(K−1) may have particular characteristics (e.g., non-idealities ofinterconnect, mixers, switches, attenuators, amplifiers, and/or circuitsalong the paths) to be accounted for by the pulse modificationoperations. Similarly, each quantum element 122 ₀-122 _(k) may have aparticular characteristics (e.g. resonance frequency, frame ofreference, etc.). In an example implementation, the number of pulsemodification settings, K, stored in the circuits 504 corresponds to thenumber of quantum element 122 ₀-122 _(K−1) and of signal paths 313 ₀-313_(K−1) such that each of the modification settings circuits 504 ₀-504_(K−1) stores modification settings for a respective one of the quantumelements 122 ₀-122 _(K−1) and/or paths 313 ₀-313 _(K−1). In otherimplementations, there may be more or fewer pulse modification circuits504 than signal paths 313 and more or fewer pulse modification circuits504 than quantum elements 122 and more or fewer signal paths 313 thanquantum elements 122. The control circuitry 502 may load values into themodification settings circuit 504 ₀-504 _(K−1) via signal 503.

The routing circuitry 506 is operable to route modification settingsfrom the modification settings circuits 504 ₀-504 _(L−1) to the pulseoperations circuit 358 (as ops_confg₀-ops_confg_(L−1)) and to thepulsers 302 ₀-302 _(L−1) (as f_dmod₀-f_dmod_(L−1)). In the exampleimplementation shown, which of the modification settings circuits 504₀-504 _(K−1) has its/their contents sent to which of the pulsemodification circuits 508 ₀-508 _(R−1) and to which of the pulsers 302₀-302 _(L−1) is controlled by the signal 505 from the control circuitry502.

The signal ops_slct_(l) informs the pulse operations manager 356 as towhich modification settings 504 _(k) to send to the pulse modificationcircuit 508 _(l). The pulser 302 _(l) may determine ops_slct_(l) basedon the particular quantum element 122 _(k) and/or signal path 313 _(k)to which the pulse is to be transmitted (e.g., the resonant frequency ofthe quantum element, frame of reference, and/or mixer correction). Thedetermination of which quantum element and/or signal path to which aparticular pulser 302 ₁ is to send an outbound pulse at a particulartime may be predetermined in the pulse program description 206 or may bedetermined based on calculations performed by the pulser 302 ₁ and/orothers of the pulsers 302 ₀-302 _(L−1) during runtime. The controlcircuitry 502 may then use this information to configure the routingblock 506 such that the correct modification settings are routed to thecorrect one or more of the pulse modification circuits 508 ₀-508 _(L−1).

In an example implementation, the digital signal IF_(l) instructs thepulse operations manager 356 to update a frequency setting of themodification settings circuit 504 _(k) indicated by ops_slct_(l). In anexample implementation, the frequency setting is the matrix S_(k)(described above) and the signal IF_(l) carries new values indicatingthe new ω_(k) to be used in the elements of the matrix S_(k). The newvalues may, for example, be determined during a calibration routine(e.g., performed as an initial portion of the quantum algorithm) inwhich one or more of the pulsers 302 ₀-302 _(L−1) sends a series ofoutbound pulses CP, each at a different carrier frequency, and thenmeasures the corresponding inbound signals AI.

In an example implementation, the signal F_(l) instructs the pulseoperations manager 356 to update a frame setting of the modificationsettings circuit 504 _(k) indicated by ops_slct_(l). In an exampleimplementation, the frame setting is the matrix F_(k) (described above)and the signal F_(l) carries a rotation matrix F_(l) which multiplieswith F_(k) to rotate F_(k). This can be written as

${F_{k} = {{F_{1}F_{k}} = {{\begin{pmatrix}{\cos\;({\Delta\phi})} & {- {\sin({\Delta\phi})}} \\{\sin({\Delta\phi})} & {\cos\;({\Delta\phi})}\end{pmatrix}\begin{pmatrix}{\cos\;\left( \phi_{k} \right)} & {- {\sin\left( \phi_{k} \right)}} \\{\sin\left( \phi_{k} \right)} & {\cos\;\left( \phi_{k} \right)}\end{pmatrix}} = \begin{pmatrix}{\cos\;\left( {\phi_{k} + {\Delta\phi}} \right)} & {- {\sin\left( {\phi_{k} + {\Delta\phi}} \right)}} \\{\sin\left( {\phi_{k} + {\Delta\phi}} \right)} & {\cos\;\left( {\phi_{k} + {\Delta\phi}} \right)}\end{pmatrix}}}},$

where ϕ_(k) is the frame of reference before the rotation and Δϕ is theamount by which to rotate the frame of reference. The pulser 302 _(l)may determine Δϕ based on a predetermined algorithm or based oncalculations performed by the pulsers 302 _(l) and/or others of thepulsers 302 ₀-302 _(L−1) during runtime.

In an example implementation, the signal dmod_sclt_(l) informs the pulseoperations manager 356 from which of the modification settings circuits504 _(k) to retrieve values to be sent to pulser 302 _(l) as f_dmod_(l).The pulser 302 _(l) may determine dmod_slct_(l) based on the particularquantum element 122 _(k) and/or signal path 315 _(k) from which thepulse to be processed arrived. The determination of from which quantumelement and/or signal path a particular pulser 302 _(l) is to process aninbound pulse at a particular time may be predetermined in the pulseprogram description 206 or may be determined based on calculationsperformed by the pulser 302 _(l) and/or others of the pulsers 302 ₀-302_(L−1) during runtime. The control circuitry 502 may then use thisinformation to configure the routing block 506 such that the correctmodification settings are routed to the correct one of the pulsers 302₀-302 _(L−1). For example, when pulse generation circuit 302 _(l) needsto demodulate a pulse signal AI_(l) from quantum element 122 _(k), itwill send a dmod_sclt_(l) signal instructing the pulse operation manager356 to rout the element SF_(k00)=cos(ω_(k)*time_stamp+ϕ_(k)) frommodification settings circuit 504 _(k) to pulser 302 _(l) (asf_dmod_(l)).

In the example implementation shown, the digital signals C₀-C_(K−1)provide information about signal-path-specific modification settings tobe used for each of the signal paths 313 ₀-313 _(K−1). For example, eachsignal C_(k) may comprise a matrix to be multiplied by a matrixrepresentation of a raw outbound pulse CP′_(l) such that the resultingoutput outbound pulse is pre-compensated for errors (e.g., resultingfrom imperfections in mixers, amplifiers, wiring, etc.) introduced asthe outbound pulse propagates along signal path 313 _(k). The result ofthe pre-compensation is that output outbound pulse CP_(l) will have theproper characteristics upon arriving at the quantum processor 218. Thesignals C₀-C_(K−1) may, for example, be calculated by the quantumcontroller 210 itself, by the programming subsystem 202, and/or byexternal calibration equipment and provided via I/O manager 368. Thecalculation of signals may be done as part of a calibration routinewhich may be performed before a quantum algorithm and/or may bedetermined/adapted in real-time as part of a quantum algorithm (e.g., tocompensate for temperature changes during the quantum algorithm).

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B. In the example implementation shown, the frequencygeneration circuitry is part of control circuitry 502 of pulseoperations manager circuitry 356. The frequency generation circuitrycomprises K coordinate rotation digital computer (CORDIC) circuits 602₀-602 _(K−1), phase generation circuitry 604, timestamp register 606,and S-Matrix generation circuitry 608.

Each CORDIC circuit 602 _(k) is operable to compute cosine and sine ofits input, θ_(k), thus generating two signals cos(θ_(k)) and sin(θ_(k)).

The phase generation circuitry 604 is operable to generate the CORDICinput parameters θ₀-θ_(k−1) based on: (1) the frequency setting signalsIF₀-IF_(L−1) from the pulsers 302 ₀-302 _(L−1); and (2) the contents,TS, of the timestamp register 606.

The timestamp register 606 comprises circuitry (e.g., a counterincremented on each cycle of the clock signal clk1) operable to trackthe number of cycles of clk1 since a reference point in time (e.g.,power up of the quantum controller 210, start of execution of set ofinstructions of a quantum algorithm by the quantum controller 210,etc.).

In the example shown, the phase generation circuitry 604 setsθ₀=2πf₀(TS)(dt_(clk1)), where f₀ is a frequency determined from thesignal IF₀, TS is the number of clock cycles counted from the referencepoint and dt_(clk1) is the duration of a single clock cycle of clk1.This leads to the CORDIC outputs being a pair of phase-quadraturereference signals, cos(2πf₀(TS)(dt_(clk1))) andsin(2πf₀(TS)(dt_(clk1))), as in the example shown, which are used togenerate the S₀ rotation matrix that rotates at a frequency f₀.

As shown in FIG. 6B, the signal IF_(l) may comprise an update componentand an f_(l) component. In an example implementation, when update_(l) isasserted then the phase generation circuitry updates one of more off₀-f_(K−1) to be the value of f_(l).

The S-matrix generation circuitry 608 is operable to build the matricesS₀-S_(K−1) from the outputs of the CORDIC circuits 602 ₀-602 _(K−1). Inan example implementation, the S-matrix generation circuit 608 isoperable to synchronize changes to the S matrices such that any matrixupdate occurs on a desired cycle of clock clk1 (which may be determinedby the control information IF₀-IF_(L-1)).

With K CORDIC circuits 602 _(k), the frequency generation circuitry isoperable to concurrently generate K S-matrices. In instances that morethan K frequencies are needed over the course of a set of instructions,the phase generation circuit 604 is operable to change the inputparameter θ_(k) of one or more of the CORDIC circuits 602 ₀-602 _(K−1)to stop generating one frequency and start generating the K+1^(th)frequency. In some instances, it may be necessary for the new frequencyto start at a phase θ that would have been the phase if the newfrequency was being generated from the initial reference time (e.g.,because the new frequency would be used to address a quantum elementthat has a resonance at the new frequency and that was coherent sincethe reference point). In some other instances, it might be necessary tostart the new frequency from the phase that the old frequency ended in.The phase generation circuit 604 and timestamp register 606 enable bothof these possibilities.

FIG. 7 shows an example implementation of the digital manager of FIG.3B. Shown in FIG. 7 are the digital manager 376, controlled circuits 710₀-710 _(J−1), and input manager 372.

The example implementation of the digital manager 376 comprises inputrouting circuit 702, configuration circuit 704, output routing circuit706, processing paths 708 ₀-708 _(Z−1) (where Z is an integer), androuting control circuit 712.

The configuration circuit 704 is operable to store configurationsettings and use those settings to configure the processing paths 708₀-708 _(Z−1) and/or the routing control circuit 712. The settings may,for example, be loaded via the signal DM_config as part of the pulseprogram description 206 provided by quantum programming subsystem 202.The settings may comprise, for example, one or more of: a bitmap onwhich may be based a determination of which of signals D₀-D_(L−1) toroute to which of signals P′₀-P′_(Z−1) for one or more instructions of apulse program; a bitmap on which may be based a determination of whichprocessing path outputs P₀-P_(Z−1) to route to which ofDigOut₀-DigOut_(J+M−1) for one or more instructions of a pulse program;and one or more bit patterns which processing paths 708 ₀-708 _(Z−1) mayconvolve with one or more of the signals P′₀-P′_(Z−1) for one or moreinstructions of a pulse program.

The input routing circuit 702 is operable to route each of the digitalsignals D₀-D_(L−1) to one or more of the processing paths 708 ₀-708_(Z−1). At any given time (e.g., for any particular instruction of everypulser 302 _(l) of pulsers 302 ₀-302 _(L)), the input routing circuit702 may determine to which of the processing paths 708 ₀-708 _(Z−1) torout the signal D_(l) of signals D₀-D_(L−1) based on the signalfanin_(l) of signals fanin₀-fanin_(L−1). That is, for a particularinstruction, the digital signal D_(l) may be routed to any one or moreof paths 708 ₀-708 _(Z−1) based on the value of fanin_(l) for thatinstruction. For example, fanin_(l) may be a Z-bit signal and a state ofeach bit of fanin_(l) during a particular instruction may indicatewhether D_(l) is to be routed to a corresponding one of the Z processingpaths 708 ₀-708 _(Z−1) during that instruction. An exampleimplementation of the input routing circuit 702 is described below withreference to FIG. 8.

The output routing circuit 706 is operable to route each of the digitalsignals P₀-P_(Z−1) to one or more of DigOut₀-DigOut_(J+M−1) (In theexample shown DigOut₀-DigOut_(J+M−1) connect to stream₀-stream_(M−1),respectively, and DigOut_(M)-DigOut_(J+M−1) connect toDigCtrl0-DigCtrlJ−1, respectively). At any given time (e.g., for anyparticular instruction of every pulser 302 _(l) of pulsers 302 ₀-302_(L)), the output routing circuit 706 may determine to which ofDigOut₀-DigOut_(J+M−1) to rout the signal Pi of the signals P₀-P_(L−1)based on the signal fanout_(l) of signals fanout₀-fanout_(Z−1). That is,for a particular instruction, the digital signal P_(z) (z an integerbetween 0 and Z) may be routed to any one or more ofDigOut₀-DigOut_(J+M−1) based on the value of fanout_(z) for thatinstruction. For example, values of fanout_(z) may be (J+M−1) bits and astate of each bit of fanout_(z) during a particular instruction mayindicate whether P_(z) is to be routed to a corresponding one of theJ+M−1 signals DigOut during that instruction. An example implementationof the output routing circuit 706 is described below with reference toFIG. 8.

Each of the processing path circuits 708 ₀-708 _(Z−1) is operable tomanipulate a respective one of signals P′₀-P′_(Z−1) to generate acorresponding manipulated signal P₀-P_(Z−1). The manipulation maycomprise, for example, introducing a delay to the signal such that theresulting one or more of DigOut₀-DigOut_(J+M−1) reach(es) its/theirdestination (a controlled circuit 710 and/or input manager 372) at theproper time with respect to the time of arrival of a correspondingquantum control pulse at the corresponding destination.

Each of the controlled circuits 710 ₀-710 _(J−1) and input manager 372is a circuit which, at least some of the time, needs to operatesynchronously with quantum control pulses generated by one or more ofpulsers 302 ₀-302 _(L−1) (possibly a reflection/return pulse from aquantum processor in the case of input manager 372). Accordingly, eachof the control circuits 710 ₀-710 _(J−1) receives a respective one ofcontrol signals DigOut₀-DigCtrl_(J−1). that is synchronized with arespective quantum control pulse. Similarly, input manager 372 receivesa plurality of the DigOut signals (one for each stream input).

The routing controller 712 comprises circuitry operable to generatesignals fanin₀-fanin_(L−1) and fanout₀-fanout_(Z−1) based onD_path₀-D_path_(L−1), D_port₀-D_port_(L−1), and/or information stored inconfiguration circuit 704.

FIG. 8 shows an example implementation of the digital manager of FIG.3B. The example input routing circuit 502 comprises routing circuits 802₀-802 _(L−1) and combining circuits 804 ₀-804 _(L−1). The example outputrouting circuitry 506 comprises circuits routing circuits 808 ₀-808_(Z−1) and combining circuits 810 ₀-810 _(J−1). The example processingpath circuits are convolution circuits 806 ₀-806 _(Z−1).

Each of the routing circuits 802 ₀-802 _(L) is operable to route arespective one of signals D₀-D_(L−1) to one or more of the combiningcircuits 804 ₀-804 _(Z−1). To which of combining circuit(s) 804 ₀-804_(Z−1) the signal D_(l) is routed is determined based on the signalfanin_(l). In an example implementation, each signal fanin_(l) is aZ-bits signal and, for a pulser_(l) instruction, the value of bit z ofthe signal fanin_(l) determines whether the signal D_(l) is to be routedto combining circuit 804 _(z) for that instruction. The value offanin_(l) may be updated on a per-instruction basis.

Each of combining circuits 804 ₀-804 _(L−1) is operable to combine up toL of the signals D₀-D_(L−1) to generate a corresponding one of signalsP₀-P_(Z−1). In an example implementation, the combining comprises OR-ingtogether the values of the up to L signals.

Each of the routing circuits 808 ₀-808 _(Z−1) is operable to route arespective one of signals P′₀-P′_(Z−1) to one or more of the combiningcircuits 810 ₀-810 _(J−1). To which of combining circuit(s) 810 ₀-810_(J−1) the signal P′_(z) is routed is determined based on the signalfanout_(z). In an example implementation, each signal fanout_(z) is a(J+M−1)-bit signal and the value of bit j+m−1 of the signal fanout_(z)determines whether the signal P′_(z) is to be routed to combiningcircuit 804 _(j+m−1). In an example implementation the value offanout_(z) is preconfigured before the runtime of the pulse program,however, in another implementation it may be updated dynamically (e.g.,on a per-instruction basis).

Each combining circuit of combining circuits 810 ₀-810 _(J−1) isoperable to combine up to Z of the signals P′₀-P′_(Z−1) (received viainputs 803 ₀ to 803 _(Z−1)) to generate a corresponding one of signalsDigOut₀-DigOut_(J+M−1). In an example implementation, the combiningcomprises OR-ing together the values of the up to Z signals.

Each convolution circuit 806 _(z) is operable to convolve signal P_(z)with pattern_(z) to generate signal P′_(z). In an exampleimplementation, pattern_(z) is preconfigured before runtime of the pulseprogram, however, in another implementation it may be updateddynamically. pattern_(z) may be determined based on: the destination(s)of signal P_(z) (e.g., to which of controlled circuits 510 and/or inputof input manager 352 Pz is intended); characteristics of thecorresponding quantum control pulse (e.g., any one or more of itsfrequency, phase, amplitude, slope, chirp rate, and/or duration); and/orprocess, temperature, and/or voltage variations.

FIG. 9A illustrates configuration and control of the quantum controllervia the quantum programming subsystem. In FIG. 9A, the quantumcontroller 210 comprises one or more instances of various circuits (suchas the pulser, input manager, ouput manager, digital manager, pulseoperations manager, and analog front end circuits described above).Connected to the inputs and outputs of the quantum controller 210 may bea plurality of external devices (e.g., oscilloscopes, waveformgenerators, spectrum analyzers, mixers, amplifiers, etc.) and aplurality of quantum elements. As described in further detail below,these physical circuits can be allocated and deallocated independentlyof one another such that the physical resources of the quantumcontroller 210, and the quantum elements and external devices connectedto the quantum controller 210 via the analog and digital inputs andoutputs, can be organized into one or more “quantum machines.”

Also shown in FIG. 9A are a compiler 906 and quantum machines manager908 of the quantum programming subsystem 202.

The compiler 906 comprises circuitry operable to generate a machine codepulse program description 206 based on: (1) a specification 902; (2) apulse generation program 904; and (3) a resources management datastructure from the quantum machines manager 908.

Referring to FIG. 9B, an example implementation of the compiler 906comprises analyzer circuitry 952 and synthesizer circuitry 954. Theanalyzer circuitry 952 is operable to parse the specification 902 andprogram 904 to generate an intermediate code representation (e.g., aparse tree). The synthesizer circuitry 954 is operable to generatemachine code based on the intermediate code representation and theavailable resources indicated by the quantum machines manager 908.

The specification 902 identifies resources of a quantum machine some ofwhich are mapped to physical circuits during an instantiation of aquantum machines (e.g. input and output ports of the quantum controller210), and some of which the compiler attaches to physical circuits ofthe quantum controller 210 during compilation of a Pulse generationProgram 904. The compiler 906 may allocate resources for executing theprogram 904 based on the specification 902, the program 904, and/or theavailable resources indicated by the quantum machines manager 908. As anexample, assume a scenario in which there are five quantum elements inthe specification 902 and the program 904 uses only two of the quantumelements; the number of the pulsers 302 ₀-302 _(L) allocated may dependon the available resources and the specifics of the program 904. In onecase the compiler 906 may allocate a first number (e.g., two) of thepulsers 302 ₀-302 _(L) for interfacing with the two quantum elements andin another case the compiler may allocate a second number (e.g., four)for sending pulses to the two quantum elements. Examples of resourcedefinitions which may be present in specification 902 are describedbelow with reference to FIGS. 10A-C. In an example implementation,Python is used as a “host” language for the specification and thespecification is a Python dictionary. In this example implementation thePython syntax/constructs can thus be leveraged to create thespecification (Python variables, functions, etc.).

The pulse generation program 904 comprises statements that define asequence of operations to be performed by the quantum machine defined inthe specification 902. Such operations typically include the generationof one or more analog pulses to be sent to a controlled element, such asa quantum element. Such operations typically include measuring one ormore return pulses from an element. The pulse generation program is alsoreferred to herein as a QUA program. Functions, syntax, etc. of the QUAprogramming language are described below. In an example implementation,Python is used as a “host” language for the QUA program. This allowsleveraging Python syntax/constructs (Python variables, functions, etc.)to generate the QUA program, but it is still a QUA-not Python-program tobe compiled by the compiler 906 to generate QOP machine code, and to beexecuted on the quantum controller/s 210.

In an example implementation, a QUA program defines the sequence ofstatements for: (1) Generating, shaping and sending pulses to thequantum device; (2) Measuring of pulses returning from the quantumdevice; (3) Performing real-time classical calculations on the measureddata and storing results in classical variables; (4) Performingreal-time classical calculations on classical variables; (5) Controllingthe flow of the program, including branching statements; and (6)Streaming of data from the quantum controller 210 to the quantumprograming system 202 and processing and saving it in the quantumprograming system 202.

In addition to the specification of which pulses are played, a QUAprogram can also specify when they should be played through bothexplicit and implicit statements and dependency constructs. Thus, a QUAprogram can define exactly the timing in which pulses are played, downto the single sample level and single clock cycles of the quantumcontroller 210.

In an example implementation, the pulses syntax defines an implicitpulse dependency, which determines the order of pulse execution. Thedependency can be summarized as follows: (1) Each pulse is playedimmediately, unless dependent on a previous pulse yet to be played; (2)Pulses applied to the same quantum element are dependent on each otheraccording to the order in which they are written in the program Inanother implementation, timing and ordering or pulses may be set forthexplicitly in the QUA program.

Example QUA programming constructs are described below in Table 1.

TABLE 1 QUA programming constructs play(pulse * amp(g₀₀, g₀₁, g₁₀, g₁₁),qe, duration=None, condition=None, break_condition=None ) Play a pulseto an element. The pulse will be modified according to the properties ofthe element defined in the specification, and then played to the analogoutput(s) defined in the specification. Parameters:     pulse - name ofthe pulse, as defined in the quantum machine specification.     qe -name of the quantum element, as defined in the quantum machinespecification.     duration - duration of the pulse (″=None″ meansdefault is no explicit duration)     g_(ij) - an expression;     amp() - matrix definition;     condition - if present, the pulse will beplayed with the condition evaluates to true (″=None″     means defaultis no condition);     break_condition - if present, the pulser will bestopped when the condition evaluates to true     (″=None″ means defaultis no break_condition); It is possible to scale the pulse′s amplitudedynamically by using the following syntax:     play(pulse_name * amp(v),′element′), where amp(v) = mat(v, 0, 0, v) where v is a variable.Moreover, if the pulse is intended for an element that receives a pulsepair and thus is defined with two waveforms, the two waveforms,described as a column vector, can be multiplied by a matrix:    play(′pulse_name′ * amp([v_00, v_01, v_10, v_11]), ′element′), wherev_ij, i,j={0,1}, are variables. Example:     >>> with program( ) asprog:     >>>  v1 = declare(fixed)     >>>  assign(v1, 0.3)     >>> play(′pulse1′, ′qe1′)     >>>  play(′pulse1′ * amp(0.5), ′qe1′)     >>> play(′pulse1′ * amp(v1), ′qe1′)     >>>  play(′pulse1′ * amp([0.9, v1,−v1, 0.9]), ′qe_iq_pair′) wait(duration, *qes) Wait for the givenduration on all provided elements. During the wait command the quantumcontroller 210 will output 0.0 to the elements.  Parameters: duration(int / QUA variable of type int) - time to wait (e.g., in multiples of4nsec       with Range: [4, 2²⁴] in steps of 1).       *qes (str /sequence of str) - elements to wait on (the asterix denotes there can be      0 or more) wait_for_trigger(element, pulse_to_play) Wait for anexternal trigger on the provided element. During the wait command thequantum controller 210 will output 0.0 to the elements.  Parameters:element (str) - element to wait on.       pulse_to_play (str / None) -the name of the pulse to play on the element while       waiting for theexternal trigger. Must be a constant pulse. Can be None to play      nothing while waiting. measure(pulse, qe, Rvar, *outputs) Themeasure statement allows operating on a quantum element (which hasoutputs), by sending a pulse to it, after some time acquiring thereturning signal and processing it in various ways An element for whicha measurement is applied must have outputs defined in the quatum machinespecification. A measurement may comprise:   • playing a pulse to theelement (identical to a play statement)   • waiting for a duration oftime defined as the time_of_flight in the definition of the element,    and then sampling the returning pulse. The analog input to besampled is defined in the     definition of the element.   • processingthe returned samples using the listed process(es) (if any). Theprocessing could be,     for example, demodulation and integration withspecified integration parameters, which may     produce a scalar or avector; filtering by a FIR filter, and/or processing by in a neural    network. Parameters   pulse - name of the pulse, as defined in thequantum machine specification. Pulse must have   a measurementoperation.   qe - name of the element, as defined in the quantum machinespecification. The element must   have outputs.   Rvar - a resultvariable reference, a string, or ′None′. If Rvar is a result variablereference, the   raw ADC data will be sent to the quantum programingsubsystem 202 and processed there   according to the result processingsection of the QUA program. If Rvar is a string the raw ADC   data willbe sent to the quantum programming subsystem 202 and saved as it is withthe default   minimal processing. If Rvar is set to None, raw resultswill not be sent to quantum programming   subsystem 202 and will not besaved. In one implementation, the raw results will be saved as   long asthe digital pulse that is played with pulse is high.   outputs - a tuplewith the form (processing identifier, params, variable name), where:    processing reference        defined in the top-level specificationand/or in reserved words of the QUA language        and referred to inthe pulse definition.     Params        parameters passed to theprocessing reference     variable name       the name of a QUA variableto which the processing result is assigned.   zero or more output tuplesmay be defined. Example: >>> with program( ) as prog: >>>  I =declare(fixed) >>>  Q = declare(fixed) >>> >>>  # measure by playing′meas_pulse1′ to QE ′rr1′, do not save raw results. >>>  # demodulateand integrate using ′cos_weights′ and store result in I, and also >>>  #demodulate and integrate using ′sin_weights′ and store result in Q >>> measure(′meas_pulse1′, ′rr1′, None, (′int′, ′cos_weights′, I), (′int′′sin_weights′, Q)) >>> >>>  # measure by playing ′meas_pulse2′ to QE′rr1′, save raw results to tag ′samples′. >>>  # demodulate andintegrate data from ′out1′ port of ‘rr1′ using the ′optimized_weights′integration parameters >>>  # store result in I >>> measure(′meas_pulse2′, ′rr1′, ′samples′, (′int′, ′optimized_weights′,′out1′, I)) align(*qes)     Align several quantum elements together.    All of the quantum elements referenced in *qes will wait for all theothers to finish their     currently running statement.     Parameters    • *qes (str / sequence of str) - a single quantum element, or listof quantum elements pause( )     Pause the execution of the job untilQmJob.resume( ) is called.     The quantum machines freezes on itscurrent output state. declare(t)     Declare a QUA variable to be usedin subsequent expressions and assignments.     Declaration is performedby declaring a python variable with the return value of this    function.     Parameters     • t - The type of QUA variable.Possible values: int, fixed, bool, where:        int         a signed32-bit number        fixed         a signed 4.28 fixed point number       bool         either True or False     Returns     The variable    Example:     >>> a = declare(fixed)     >>> play(′pulse′ * amp(a),′qe′) assign(var,_exp)     Set the value of a given QUA variable.    Parameters     • var (QUA variable) - The variable to set (definedby the declare function)     • _exp (QUA expression) - An expression toset the variable to     Example:     >>> with program( ) as prog:    >>>  v1 = declare(fixed)     >>>  assign(v1, 1.3)     >>> play(′pulse1′ * amp(v1), ′qe1′) save(var, tag)     Save a QUA variablewith a given tag.     The tag will appear later as a field in the savedresults object returned by QmJob.get_     results( ).     The type ofthe variable determines the python type, according to the followingrule:     • int -> int     • fixed -> float     • bool -> bool    Parameters     • var (QUA variable) - A QUA variable to save     •tag (str) - A name to save the value under update_frequency(qe,new_frequency)     Dynamically update the frequency of the NCOassociated with a given quantum element.     This changes the frequencyfrom the value defined in the quantum machine specification.    Parameters     • qe (str) - The quantum element associated with theNCO whose frequency will be       changed     • new_frequency (int) -The new frequency value to set in units of Hz. Range: (0 to      5000000) in steps of 1.     Example:     >>> with program( ) asprog:     >>>  update_frequency(″q1″, 4000000) z_rotation(angle, *qes)    Shift the phase of the NCO associated with a quantum element by thegiven angle.     This is typically used for virtual z-rotations.Equivalent to z_rot( )     Parameters     • angle (float) - The angle toadd to the current phase (in radians)     • *qes (str / sequence ofstr) - A quantum element, or sequence of quantum elements,      associated with the NCO whose phase will be shifted z_rot(angle,*qes)     Shift the phase of the NCO associated with a quantum elementby the given angle.     This is typically used for virtual z-rotations.Equivalent to z_rotation( )     Parameters     • angle (float) - Theangle to add to the current phase (in radians)     • *qes (str /sequence of str) - A quantum element, or sequence of quantum elements,      associated with the NCO whose phase will be shifted set_frame(qes,angle)     Set the phase of the frame matrix associated with a quantumelement to the given angle. reset_phase(qes, angle)     Set the totalphase of the frequency modulation of a quantum element to zero (both the    frequency modulation matrix and the frame matrix). infinite_loop_( )    Infinite loop flow control statement in QUA.     To be used with acontext manager.     Optimized for zero latency between iterations,provided that no more than a single quantum     element appears in theloop.     Note     In case multiple quantum elements need to be used inan infinite loop, it is possible to add     several loops in parallel(see example).     Example:     >>> with infinite_loop_( ):     >>> play(pulser, ′qe1′)     >>> with infinite_loop_( ):     >>> play(′pulse2′, ′qe2′)  for(vor=None, init=None, cond=None, update=None)    For loop flow control statement in QUA.     To be used with acontext manager.     Parameters     • var (QUA variable) - QUA variableused as iteration variable     • init (QUA expression) - an expressionwhich sets the initial value of the iteration variable     • cond (QUAexpression) - an expression which evaluates to a boolean variable,determines      if to continue to next loop iteration     • update (QUAexpression) - an expression to add to var with each loop iteration    Example:     >>> x = declare(fixed)     >>> with for(var=x, init=0,cond=x<=1, update=x+0.1):     >>>  play(′pulse′, ′qe′)  if(condition)    If flow control statement in QUA.     To be used with a contextmanager.     The QUA code block following the statement will be executedonly if condition evaluates     to true.     Parameters     •condition - A boolean expression to evaluate     Example:     >>>x=declare(int)     >>> with if_(x>0):     >>>  play(′pulse′, ′qe′) else    Else flow control statement in QUA.     To be used with a contextmanager.     Must appear after an if( ) statement.     The QUA codeblock following the statement will be executed only if expression in    preceding if( ) statement evaluates to false.     Example:     >>>x=declare(int)     >>> with if(x>0):     >>>  play(′pulse′, ′qe′)    >>> with else( ):     >>>  play(′other_pulse′, ′qe′) IO1, IO2    Reserved variables which operate just like other QUA variables butwhich refer to dedicated     registers/memory locations in the I/OManager 368 that can be read from and written to in     real time in apulse program and via the quantum machine manager API (an example of    which is shown below in Table 6).     Example usage in a QUAprogram:      >>> pause( )      >>> play(pulse1*amp(IO1), qubit2)

The Play statement in QUA instructs the quantum controller 210 to sendthe indicated pulse to the indicated element. The quantum controller 210will modify or manipulate the pulse according to the element'sproperties defined in the quantum machine specification (i.e., thecompiler will generate the required pulse modification settings whichwill then be stored to the appropriate one or more of pulse modificationsettings circuit(s) 504 ₀-504 _(K−1)), so the user is relieved of theburden of having to specify the modifications/manipulations in eachindividual Play statement.

If the element has a single input, the pulse sent to it may be definedwith a single waveform. For example:

‘elements’: {   ‘qubit’: {    ‘SingleInput’: {     ‘port’: (‘con1’, 1),   }    ‘intermediate_frequency’: 70e6,    ‘operations’: {     ‘pulse1’:‘pulse1’    },   }, } ‘pulses’: {   ‘gauss_pulse_in’: {    ‘operation’:‘control’,    ‘length’: 12,    ‘waveforms’: {     ‘single’: ‘wf1’,    },  }  }, ‘waveforms’: {   ‘wf1’: {    ‘type’: ‘arbitrary’,     ‘samples’:[0.49, 0.47, 0.44, 0.41, 0.37, 0.32, 0.32, 0.37,      0.41, 0.44, 0.47, 0.49]   }, }

Denoting the samples of the waveform as s_(i), the play statementinstructs the quantum controller 210 to modulate the waveform sampleswith the intermediate frequency of the element:

{tilde over (s)} _(ι) =s _(i) cos(ω_(lF) t+ϕ _(F))

ω_(lF), is the intermediate frequency defined in the quantum machinespecification of the element and ϕ_(F) is the frame phase, initially setto zero (see z_rot statement specifications for information on ϕ_(F)).The quantum controller 210 then plays s_(i) to the analog output portdefined in the definition of the element (in the above example, port 1).

If the element has two mixed inputs (i.e. two output ports of thequantum controller 210 are connected to the element via an IQ mixer), inaddition to the intermediate frequency, a mixer and a lo_frequency maybe defined in the quantum machine specification. For example:

  ‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 1),   ‘Q’: (‘con1’, 2),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 5.1e9,  },   ‘intermediate_frequency’: 70e6,   ‘operations’: {    ‘pulse1’:‘pulse1’   },  }, },

A pulse that is sent to such element may be defined with two waveforms.For example:

‘pulses’: {   ‘pulse1’: {    ‘operation’: ‘control’,    ‘length’: 12,   ‘waveforms’: {     ‘I’: ‘wf_I’,     ‘Q.’: ‘wf_Q’,    },   },  },‘waveforms’: {   ‘wf_I’: {    ‘type’: ‘arbitrary’,    ‘samples’:[0.49,0.47, 0.44, 0.41, 0.37, 0.32, 0.32, 0.37,      0.41, 0.44, 0.47, 0.49]  },   ‘wf_Q’: {    ‘type’: ‘arbitrary’,    ‘samples’: [0.02, 0.03,0.03, 0.04, 0.05, 0.00, 0.05, 0.04,      0.03, 0.03, 0.02, 0.02]  }, }

In addition, a mixer can be defined with a mixer correction matrix thatcorresponds to the intermediate_frequency and the lo_frequency. Forexample:

  ‘mixers’: {  ‘mixed’: [   {    ‘intermediate_frequency’: 70e6,   ‘lo_frequency’: 5.1e9,    ‘correction’: [0.9, 0.003, 0.0, 1.05]   } ],

Denoting the samples of the waveforms by I_(i) and Q_(i), the playstatement instructs the quantum controller 210 to modulate the waveformsamples with the intermediate frequency of the element and to apply themixer correction matrix in the following way:

$\begin{pmatrix}{\overset{\sim}{I}}_{\iota} \\{\overset{\sim}{Q}}_{\iota}\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{\cos\left( {{\omega_{IF}t} + \phi_{F}} \right)} & {{- {\sin\left( {{\omega_{IF}t} + \phi_{F}} \right)}}\;} \\{{\sin\left( {{\omega_{IF}t} + \phi_{F}} \right)}\;} & {\cos\left( {{\omega_{IF}t} + \phi_{F}} \right.}\end{pmatrix}\begin{pmatrix}I_{i} \\Q_{i}\end{pmatrix}}$

ω_(lF) ω_(lF), is the intermediate and the C_(ij)'s are the matrixelements of the correction matrix defined in the mixer for the relevantintermediate_frequency and lo_frequency. As mentioned above, ϕ_(F) isthe frame phase, initially set to zero (see z_rot statementspecifications for information on ϕ_(F)). The quantum controller 210then plays I_(i) and Q_(i) to the analog output ports defined in thedefinition of the element (in the above example, port 1 and port 2,respectively).

An element could have digital inputs as well as analog inputs. Eachdigital input of an element may be defined with three properties: port,delay, and buffer. For example:

  ‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 1),   ‘Q’: (‘con1’, 2),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 5.1e9,  },   ‘intermediate_frequency’: 70e6,   ‘digital_inputs’:   ‘digital_input1’:     ‘port’: (cont1, 1)     ‘delay’: 144    ‘buffer’: 8    ‘digital_input2’:     ‘port’: (cont1, 2)     ‘delay’:88     ‘buffer’: 20   ‘operations’: {    ‘pulse1’: ‘pulse1’   },  }, },

For a simple example, a pulse that is played to such quantum elementcould include a single digital marker which points to a single digitalwaveform. For example:

  ‘pulses’: {   ‘pulse1’: {    ‘operation’: ‘control’,    ‘length’: 40,   ‘waveforms’: {     ‘I’: ‘wf_I’,     ‘Q’: ‘wf_Q’,    },   ‘digital_marker’: ‘digital_waveform_high’   },  },‘digital_waveforms’: {   ‘digital_waveform_high’: {    ‘samples’: [(1,0)]   }, }

The coding of the digital waveform may be a list of the form: [(value,length), (value, length), . . . , (value, length)], where each value iseither 0 or 1 indicating the digital value to be played (digital high orlow). Each length may be an integer (e.g., divisible by 4 in one exampleimplementation) indicating for how many nanoseconds the value should beplayed. A length 0 indicates that the corresponding value is to beplayed for the remaining duration of the pulse. In the example above,the digital waveform is a digital high.

When such pulse is played to the element, via the play or themeasurement command, the digital waveform may be sent to all the digitalinputs of the element. For each digital input, however, the quantumcontroller 210 may: (1) Delay the digital waveform by the delay that isdefined in the definition of the digital input (e.g., given in ns); (2)Convolve the digital waveform with a digital pattern that is high for aduration which is, for example, twice the buffer that is defined in thedefinition of the digital input (e.g., given in ns in a “buffer”); and(3) Play the digital waveform to the digital output of the quantumcontroller 210 that is indicated in the quantum machine specification tobe connected to the digital input. In other implementations, the digitalpattern with which the digital waveform to be convolved may be morecomplex than a simple high value. In one such example, the “buffer”object may comprise “duration” and “pattern” properties.

In the example above a play(pulse1, qubit) command would play: (1) Adigital waveform to digital output 1, which starts 144 ns after theanalog waveforms and which is high for 56 ns (the length of the pulseplus 2×8 ns); and (2) A digital waveform to digital output 2, whichstarts 88 ns after the analog waveforms and which is high for 80 ns (thelength of the pulse plus 2×20 ns).

A measurement can be done for an element that has outputs defined in thequantum machine specification. For example:

  ‘elements’: {  ‘resonator’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 3),   ‘Q’: (‘con1’, 4),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 7.3e9,  },   ‘intermediate_frequency’: 50e6,   ‘outputs’: {    ‘out1’: :(‘con1’, 1),   },   ‘time_of_flight’: 196,   ‘smearing’: 20,  }, },

As seen in the above example, when a quantum element has outputs, twoadditional properties may be defined: time_of_flight and smearing. Thepulse used in a measurement statement may also be defined as ameasurement pulse and may have integration_weights defined. For example:

  ‘pulses’: {  ‘pulsel’: {   ‘operation’: ‘measurement’,   ‘length’:400,   ‘waveforms’: 1    ‘I’: ‘meas_wf_I’,    ‘Q’: ‘meas_wf_Q’,   },  ‘integration_weights’: {    ‘integ1’: ‘integW1’,    ‘integ2’:‘integW2’,   } ‘integration_weights’: {  ‘integW1’: {   ‘cosine’: [0.0,0.5, 1.0, 1.0, . . . , 1.0, 0.5, 0.0]   ‘sine’: [0.0, 0.0, . . . , 0.0] },  ‘integW2’: {   ‘cosine’: [0.0, 0.0, . . . , 0.0]   ‘sine’: [0.0,0.5, 1.0, 1.0, . . . , 1.0, 0.5, 0.0]  }, }

A measurement statement, such as the one shown above, instructs thequantum controller 210 to: (1) Send the indicated pulse to the indicatedelement, manipulating the waveforms in the same manner that is describedin the play statement section above; (2) After a time periodtime_of_flight (e.g., given in ns), samples the returning pulse at thequantum controller 210 input port/s that is/are connected to theoutput/s of the element. It saves the sampled data under stream_name(unless stream_name=None, in which case the sampled data will not besaved). The sampling time window will be of a duration that is theduration of the pulse plus twice the smearing (e.g., given in ns). Thisaccounts for the returning pulse that is longer than the sent pulse dueto the response of the quantum device, as well as for the cables andother elements in the pulse's path; and (3) Process the sampled dataaccording to the parameters specified in the measure statement.

An example of processing the sampled data according to a measurestatement is demodulation of the sampled data with a frequencyintermediate_frequency, defined in the definition of the element,weighted integration of the demodulated data with integration parameters(“integration_weights”) that are defined in the quantum machinespecification and are specified in the measure statement, and storing ofthe result in the indicated variable. The quantum controller 210 canperform multiple (e.g., 10 or more) demodulations and integrations atany given point in time, which may or may not be a part of the samemeasurement statement. The precise mathematical operation on the sampleddata is:

${variable}{= {\sum\limits_{i}{s_{i}\left\lbrack {{w_{c}^{i}{\cos\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)}} + {w_{s}^{i}{\sin\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)}}} \right\rbrack}}}$

where s_(i) is the sampled data, ω_(lF) is the intermediate_frequency,ϕ_(F) is the frame phase discussed in the z_rot statement below, andw_(c) ^(i) and w_(s) ^(i) are the cosine and sine integration_weights.In an example implementation, the integration_weights are defined in atime resolution of 4 ns, while the sampling is done with time resolutionof 1 ns (1 GSa/Sec sampling rate):

w _(c/s) ^(4i) +w _(c/s) ^(4i+1) +w _(c/s) ^(4i+2) +w _(c/s) ^(4i+3)

In the above example, the integration parameters consist of a vector ofintegration weights (which may be a vector with single integrationweight to be used as a constant integration weight) and the receivedsamples of the measurement pulse are integrated to generate a scalarresult. In another implementation, the integration parameters maycomprise an integration weights vector and other parameters to be usedfor specifying how to perform a series of integrations to generate avector of integration results rather than a scalar. For simplicity, thefollowing examples use integrations that results in two-element vectors,but other implementations may generate vectors with three or moreelements.

For example, the integration parameters may specify a first set ofintegration weights to be used for a first plurality of samples of thereceived measurement pulse (e.g., a first 100 ns of the pulse), and asecond set of integration weights to be used for a second plurality ofsamples of the received measurement pulse (e.g., a second 100 ns of thepulse). The parameters may also indicate whether the integration of eachportion should start from zero (referred to here as “chunkedintegration”) or accumulated with the result from the previous portion(referred to here as “accumulated” integration).

Another option is the integration parameters may indicate theintegration is to generate a moving average. The integration parametersmay specify a length an offset of integration windows on which chunkedintegration is to be performed using those windows. For example, theparameters may specify 100 ns windows offset by 40 ns and then chunkedintegration may be performed on samples of the measurement pulse from 0to 100 ns, from 40 ns to 140 ns, from 80 ns to 180 ns, and so on for theduration of the pulse.

Another example of processing the sampled data according to a measurestatement is processing of the data by a neural network with parametersdefined in the quantum machine specification and/or specified in themeasure statement and storing of the result in the indicated variablewhich can be a scalar or a vector.

Another example of processing the sampled data according to a measurestatement is when the element's output is a digital output and thus thesampled data is digital. One example processing of this data can becounting of the number of digital pulses that arrive to the relevantcontroller's input in a given time window. Another example may be thetime tagging of the arrival of pulses that arrive in a given time windowrelative to the beginning of the window.

Compilation may include allocating specific resources of the quantumcontroller 210 to that quantum machine and then generating machine codethat, when executed by quantum controller 210, will use those allocatedresources.

The quantum machines manager 908 comprises circuitry operable todetermine resources present in the quantum controller 210 and theavailability of those resources at any given time. To determine theresources, the quantum machines manager 908 may be operable to read oneor more configuration registers of the quantum controller 210, inspect anetlist of one or more circuits of the quantum controller 210, and/orparse hardware description language (HDL) source code used to definecircuits of the quantum controller 210 and/or other files used todescribe various configurations of the hardware and software components.Once the resources are determined, the quantum machines manager 908 maykeep track of which resources are in use and which are available basedon which quantum machines are “open” (i.e., in a state where someresources are reserved for that machine regardless of which, if any,pulse program that quantum machine is executing at that time), and/orwhich pulse programs are loaded into and/or being executed by thequantum controller 210 at that time. For example, referring briefly toFIG. 13A, during a time period where two quantum machines are open, eachexecuting one of a first two pulse programs (“Program 1” and “Program2”), the system may be configured as shown in FIG. 13A and a datastructure managed by the quantum machines manager 908 may reflect thesituation as shown in Table 2.

TABLE 2 Example data structure maintained by quantum machines managerResource Status Pulsar 1 Allocated to program 2 Pulsar 2 Allocated toprogram 2 Pulsar 3 Allocated to program 1 Pulsar 4 Available Port 1Allocated to QM2 Port 2 Available Port 3 Allocated to QM2 Port 4Allocated to QM1 Port 5 Allocated to QM1 Port 6 Allocated to QM2 Port 7Allocated to QM1 Port 8 Allocated to QM1

During another time period where a single quantum machine is open andexecuting a third pulse program (“Program 3”), the system may beconfigured as shown in FIG. 13B. The data structure managed by thequantum machines manager 908 may reflect the situation as shown in Table3.

TABLE 3 Example data structure maintained by quantum machines managerResource Status Pulsar 1 Allocated to program 3 Pulsar 2 Allocated toprogram 3 Pulsar 3 Allocated to program 3 Pulsar 4 Allocated to program3 Port 1 Allocated to QM3 Port 2 Allocated to QM3 Port 3 Allocated toQM3 Port 4 Allocated to QM3 Port 5 Allocated to QM3 Port 6 Allocated toQM3 Port 7 Allocated to QM3 Port 8 Allocated to QM3

Table 4 below shows an example schema which uses Python as a hostlanguage the quantum machine specification is one or more Pythondictionaries.

TABLE 4 Example quantum machine specification schema version integer<int32> schema version. controllers object A collection of controllers.Each controller represents a control and computation resource on thequantum controller 210 hardware. property object (controller) name*specification of a single quantum control module. Here we define itsstatic properties. analog_ object outputs a collection of analog outputports and the properties associated with them property object (quantumcontrol module analog output port) name* specification of the propertiesof a physical analog output port of the quantum control module. offsetnumber DC offset to output, range: (−0.5, 0.5). Will be applied onlywhen program runs. digital_outputs object property object (quantumcontrol module digital port) name* specification of the properties of aphysical digital output port of the quantum control module. offsetnumber analog object a collection of analog output ports and theproperties associated with them. Property object (quantum control moduleanalog output port) name* specification of the properties of a physicalanalog output port of the quantum control module. offset number DCoffset to output, range: (−0.5, 0.5). Will be applied only when programruns. type string Default: ″opx1″ analog_inputs object Property object(quantum control module analog input port) name* specification of theproperties of a physical digital input port of the quantum controlmodule. Offset number elements object A collection of quantum elementsand/or external devices. Each quantum element represents and describes acontrolled entity which is connected to the ports (analog input, analogoutput and digital outputs) of the quantum control module. property_object (quantum element (QE)) name* specification of a single element.Here we define to which port of the quantum control module the elementis connected, what is the RF frequency of the pulses sent and/orreceived from this element frequency integer <Int32> resonance frequency[Hz]. Actual carrier frequency output by the quantum control module tothe input of this QE is frequency - lo_frequency. mixInputs object(mixer input) specification of the input of a QE which is driven by anIQ mixer I string (tuple) of the form ((string) controller name, (int)controller output/input port) Q string (tuple) of the form ((string)controller name, (int) controller output/input port) mixer string themixer used to drive the input of the QE, taken from the names in mixersentry in the main quantum machine specification lo_frequency integer<int32> the frequency of the local oscillator which drives the mixeroutputs object collection of up to two output ports of QE. Keys: ″out1″and ″out2″. property_ string name* (tuple) of the form ((string)controller name, (int) controller output/input port) intermediate_integer <int32> frequency intermediate frequency [Hz]. The actualfrequency to be output by the quantum control module to the input ofthis element measurement_ String qe A reference to an element that hasoutputs (and thus can be measured using the measurement command). Thiscan be specified for any element that does not have outputs so thatwhenever a measurement command is used to measure this elements, theactual measure- ment will be of the referenced element. smearing integer<int32> padding time, in nsec, to add to both the start and end of theraw data streaming window during a measure command. time_of_flightinteger <int32> delay time [nsec] from start of pulse until output of QEreaches quantum control module. Minimal value: 180. Used in measurecommand, to determine the delay between the start of a measurement pulseand the beginning of the demodulation and/or raw data streaming window.singleInput object (single input) specification of the input of a QEwhich has a single input port port string (tuple) of the form ((string)controller name, (int) controller output/input port) operations object Acollection of all pulse names to be used in play and measure commandsproperty_ string name* the name of the pulse as it appears under the″pulses″ entry in the quantum machine specification digitalInputs objectproperty_ object (digital input) name* specification of the digitalinput of a QE port string (tuple) of the form ((string) controller name,(int) controller output/input port) delay integer <int32> the digitalpulses played to this QE will be delayed by this amount [nsec] relativeto the analog pulses. An intinsic negative delay of 143 +− 2 nsec existsby default output string (tuple) of the form ((string) controller name,(int) controller output/input port) buffer integer <int32> all digitalpulses played to this QE will be convolved with a digital pulse of value1 with this length [nsec] pulses object A collection of pulses to beplayed to the quantum elements. In the case of a measurement pulse, theproperties related to the measurement are specified as well. property_object (pulse) name* specification of a single pulse. Here we define itsanalog and digital components, as well as properties related tomeasurement associated with it. integration_ object weights ifmeasurement pulse, a collection of integration weights associated withthis pulse, to be applied to the data output from the QE and sent to thecontroller. Keys: name of integration weights to be used in themeasurement command. property_ string name* the name of the integrationweights as it appears under the ″integration_weigths″ entry in thequantum machine specification waveforms object a specification of theanalog waveform to be played with this pulse. If associated element hassinglelnput, key is ″single″. If associated element has ″mixlnputs″,keys are ″I″ and ″Q″. property_ string name* name of waveform to beplayed at the input port given in associated keys digital_ string markername of the digital marker to be played with this pulse operation stringtype of operation. Possible values: control, measurement length integer<int32> length of pulse [nsec]. Possible values: 16 to 4194304 in stepsof 4 waveforms object A collection of analog waveforms to be output whena pulse is played. Here we specify their defining type (constant,arbitrary or compressed) and their actual datapoints. property_arbitrary waveform (object) or constant waveform (object) name* orcompressed waveform (object) type ′arbitrary′ | ′constant′ |′compressed′ samples If type = ′arbitrary′: Array of numbers <float>list of values of arbitrary waveforms, range: (−0.5, 0.5) If type =′constant′: number <float> value of constant, range: (−0.5, 0.5) If type= ′compressed′: Array of numbers <float> Integer <int32> digital_ objectwaveforms A collection of digital waveforms to be output when a pulse isplayed. Here we specify their actual datapoints. property_ object(digital waveform) name* raw data samples of a digital waveform samplesArray of strings (list of tuples) specifying the analog data accordingto following code: The first entry of each tuple is 0 or 1 andcorresponds to the digital value, and the second entry is the length innsec to play the value, in steps of 1. If value is 0, the value will beplayed to end of pulse. integration_ object weights A collection ofintegration weight vectors used in the demodulation of pulses returnedfrom a quantum element. property_ object (integration weights) name*specification of a set of measurement integration weights. Result ofintegration will be: sum over i of (W_cosine[i]cos[wt[i]] +W_sine[i]sin[wt[i]])analog[i]. Here: w is the angular frequency of thequantum element, and analog[i] is the analog data acquired by thecontroller. W_cosine, W_sine are the vectors associated with the′cosine′ and ′sine′ keys, respectively. Note: the entries in the vectorare specified in 4nsec intervals, and each entry is repeated four timesduring the demodulation. Example: W_cosine = [2.0], W_sine = [0.0] willlead to the following demodulation operation: 2.0(cos[wt[0]]analog[0] +cos[wt[1]]analog[1] + cos[wt[2]]analog[2] + cos[wt[3]]analog[3]) sineArray of numbers <float> W_sine, a fixed-point vector of integrationweights, range: [−2048, 2048] in steps of 2**-15 cosine Array of numbers<float> W_cosine, a fixed-point vector of integration weights, range:[−2048, 2048]in steps of 2**-15 mixers object A collection of IQ mixercalibration properties, used to post-shape the pulse to compensate forimperfections in the mixers used for upconverting the analog waveforms.property_ Array of objects (mixer) name* intermediate_ integer <int32>frequency intermediate frequency associated with correction matrixlo_freq integer <int32> local oscillator (LO) frequency associated withcorrection matrix correction string (tuple) a 2 × 2 matrix entered as afour-element tuple specifying the correction matrix

Elements of the quantum processor, (e.g. qubits, resonators, flux lines,gates, etc.), external devices (e.g., oscilloscopes, spectrum analyzers,waveform generators, etc.), and/or any other element which is a part ofa quantum machine and is connected to output and/or input ports of thecontroller 210, are defined using one or more of the other propertiesdescribed in Table 4 and/or other similar properties which may be usedin other implementations.

An example of other properties which may be used to specify an elementare properties of a neural network that processes pulses sent to theelement. For example, an element specification may specify that pulsessent to it are to be generates and/or processed by a neural network andthe element definition may include one or more parameters specifying thenumber of layers of the neural network, the number of neurons of theneural network, the weights and biases for each neuron of the neuralnetwork, and/or other parameters familiar to those working with neuralnetworks. The neural network having the specified parameters may then betrained during a calibration routine (e.g., at the beginning ofexecution of a QUA program).

For each element defined in a specification 902, the controller outputand/or input ports to which it is connected are defined. Duringcompilation, pulse modification settings for manipulating pulsesintended for an element may be generated (for loading into pulsemodification settings circuits 504) and the pulse modification settingcircuit(s) 504 to which they will be loaded before execution may bechosen and may be allocated to the quantum machine on which the programis to be executed. Similarly, parameters and configurations ofoperations that will be performed on input signals related to an element(e.g. readout/measurement pulses) may be generated during compilation(for loading into compute and signal processing circuits 410). Likewise,the compute and signal processing circuit 410 in which they will be usedmay be chosen during compilation and may be allocated to the quantummachine on which the program is to be executed during compilation.

One example of an element that a quantum machine may contain is an IQmixer that is connected to two output ports of the controller 210. Tocorrect for mixer imbalances, the in-phase/quadrature (IQ) waveforms ofthe pulse can be multiplied by a 2×2 mixer correction matrix beforebeing sent to the output ports. This mixer correction matrix, determinedvia a calibration routine, may be frequency dependent. Thus, a mixerdefinition may include the mixer's name and a list of one or morefrequencies and the correction matrix to be used at each frequency. Inone example implementation, the correction matrix is loaded intocorresponding pulse modification circuit during compilation. Similarly,an element definition may include an intermediate frequency with whichevery pulse sent to the element is to be modulated.

An example quantum machine specification file is described below withreference to FIGS. 10A-10C. While the example implementations we showhere (including the one Table 4 refers to) show some possible propertiesthat can be defined and specified in the quantum machine specification,it is not limited to these examples. For example, various filters andtheir parameters may be defined (e.g. FIR filter) to be performed onpulses to be played to certain elements and/or on input signals to thecontroller.

Pulses available for transmission by a quantum machine may be definedusing one or more of the properties described in Table 4 and/or othersimilar properties which may be used in other implementations. Eachpulse has a length. Each pulse is made of one or more waveforms. In oneimplementation there are two types of pulses: control pulses that arepulses that are only sent to the quantum system and will not bemeasured, and measurement pulses that are sent to the quantum system andwill be measured upon return. The definition of a measurement pulse mayspecify parameters to be used for processing the measurement pulse uponits return from the element to which it was sent. Such parameters mayinclude, for example, integration weights, integration method (e.g.,normal, chunked, accumulated, moving average, etc.), parameters (e.g.,number of layers, number of neurons, weights and biases, and/or thelike) of a neural network, parameters (e.g., number of taps and tapcoefficients) of a FIR filter, and/or the like. During compilation,pulse definitions may be used to, for example: generate pulse templatesto load into pulse template memory 404; generate instructions to beloaded into instruction memory 402 and/or compute and signal processingcircuit 410 for retrieving and manipulating the contents of pulsetemplate memory 404 to achieve the defined pulses; and/or generate oneor more classical processor programs to be executed by compute andsignal processing circuit 410 for processing readout/measurement pulses.

FIGS. 10A-10C show an example quantum machine specification. The exampleshown uses Python as a host language. The example quantum machinespecification is a Python dictionary with a key of “config” and a valuethat comprises a plurality of nested objects, some of which arekey-value pairs and some of which are nested dictionaries.

The “version” key-value pair which indicates the version of the quantummachine specification schema being used.

The “controllers” object is used to specify the number of modules/unitsthat make up the quantum controller 210 of the quantum machine. Theexample shown specifies just a single quantum control module named“con1”, which is of type “opx1” (different opx types may, for example,indicated different hardware and/or configuration of the hardware). Foreach controller 210, the output and input ports that are used in thequantum machine are specified. For analog outputs and inputs, DC offsetvoltage is specified as well.

The “elements” object is used to specify elements that are connected tooutput and input ports of the controller 210. Such elements may includequantum elements (e.g., qubits, readout resonators, flux lines, etc.),external devices (e.g., test equipment such as oscilloscopes, spectrumanalyzers, signal generators, etc.), and/or any other element connectedto the output and/or input ports of the controller. The example shown inFIG. 10A specifies a qubit named “qubit” and a readout resonator named“RR”. The “qubit” element comprises “mixinputs”, “operations”, and“frequency” objects. The “mixinputs” object comprises “I”, “Q”,“lo_frequency”, and “mixer” objects. The “I” and “Q” objects specify thecorresponding output ports of “con1” to which the inputs of the elementare connected. The “intermediate_frequency” object specifies theintermediate frequency with which pulses sent to the qubit are to bemodulated (e.g., determined from a qubit calibration routine). The“mixer” object refers to mixer object “mixer_quibit,” which is definedlater in the quantum machine specification. The “operations” objectspecifies a “gauss-pulse” which refers to the “gauss_pulse_in” object isdefined later in the quantum machine specification. The “RR” elementcomprises “mixinputs”, “operations”, “outputs”, “frequency”,“time_of_flight”, and “smearing” objects. The “mixinputs” objectcomprises “I”, “Q”, “lo_frequency”, and “mixer” objects. The “I” and “Q”objects specify the corresponding ports of “con1”. The “frequency”object specifies the frequency of the readout_resonator (e.g.,determined from a qubit calibration routine). The “mixer” object refersto mixer object “mixer_res,” which is defined later in the quantummachine specification. The “operations” object specifies a “meas_pulse”which refers to the “meas_pulse_in” object is defined later in thequantum machine specification. The “time_of_flight” and “smearing”objects specify those values for the readout resonator. The “outputs”object specifies an output on the element “out1” and the correspondinginput port of “con1” to which it is connected.

The “Pulses” object is used to specify pulses available for transmissionby the quantum machine. The example shown specifies two pulses:“means_pulse_in” and “gauss_pulse_in.” The “means_pulse_in” object inturn comprises “operation”, “length”, “waveforms”,“integration_weights”, and “digital_marker” objects. The “operation”object specifies it as a “measurement” pulse. The “I” and “Q” objects ofthe “waveforms” object refer to the “exc_wf” and “zero_wf” objects whichare defined later in the quantum machine specification. The“integration_weights” object refers to the integration weights objects“integW1” and “integW2” which are defined later in the specification.The “digital_marker” object refers to the “marker1” object defined laterin the specification.

The “gauss_pulse_in” object comprises “operation”, “length”, and“waveforms” objects. The “operation” object specifies it is a “control”pulse. The “I” and “Q” objects of the “waveforms” object refer to the“gauss_wf” and “zero_wf” objects which are defined later in the quantummachine specification.

The “waveforms” object defines the “zero_wf”, “gauss_wf”, and “exc_wf”objects (“exc_wf” not shown) using “type” and “samples” objects.

The “digital_waveforms” defines the “marker1” object using a “samples”object.

The “integration_weights” object defines the objects “integW1” and“integW2” using “cosine” and “sine” objects.

The “mixers” object defines the “mixer_res” and “mixer_qubit” objectsusing “freq”, “lo_freq”, and “correction” objects.

FIG. 11 is a flow chart showing an example process for operation of thequantum orchestration platform. The process begins in block 1102 inwhich one or more quantum control modules are connected together to formquantum controller 210 and the quantum controller 210 is connected to aquantum system. In this regard, the quantum controller 210 is modularand extendable enabling use of as many units as desired/necessary forthe quantum algorithm to be performed. Each of the modules may, forexample, comprise one or more of each of the circuits shown in FIG. 3B.

In block 1103, a quantum machine with a certain specification isinstantiated by a user. This may be done via a Quantum Machines ManagerAPI. In an example of such an API, shown in Table 5, this may include acall to the open_qm( ) function or the open_qm_from_file( ) function.

TABLE 5 Quantum Machines Manager API Class QuantumMachinesManager(host=None, port=None, **kargs)  close_all_quantum_machines( )   ClosesALL open quantum machines  get_controllers( )   Returns a list of allthe quantum control modules that are available  get_qm(machine_id)  Gets an open quantum machine object with the given machine id  Parameters    machine_id - The id of the open quantum machine to get  Returns    A quantum machine obj that can be used to execute programs list_open_quantum_machines( )   Return a list of open quantum machines.(Returns only the ids, use    

  to get the machine object)   Returns   The ids list  open_qm(config,close_other_machines=True) → qm.QuantumMachine.  QuantumMachine   Opensa new quantum machine   Parameters   • config - The config that will beused by the name machine   • close_other_machines - Flag whether toclose all other running   machines   Returns    A quantum machine objthat can be used to execute programs  open_qm_from_file(filename,close_other_machines=True)   Opens a new quantum machine with configtaken from a file on the   local file system   Parameters   • filename -The path to the file that contains the config   • close_other_machines -Flag whether to close all other running   machines   Returns    Aquantum machine obj that can be used to execute programs perform_healthcheck(strict=True)   Perform a health check against theQM programming subsystem.   Parameters    strict - Will raise anexception if health check failed  version( )   Returns    The QMprogramming subsystem version

In block 1104, the quantum machines manager 908 attempts to allocatemachine resources (i.e., resources allocated to a particular quantummachine regardless of whether a pulse program is currently executing onthat quantum machine) of the quantum controller 210 to the new quantummachine according to the specification.

In block 1105, the quantum machines manager 908 determines whether theallocation and instantiation is successful. If not, then in block 1122an alert is generated for the user (e.g., to inform the user that thereare currently insufficient resources available to instantiate therequired quantum machine). If allocation is successful, then in block1106 the allocated resources are stored in quantum machines manager 908,which updates its data structure of available resources to reflect theallocation of resources to the quantum machine, the new quantum machineis instantiated, and the process advances to block 1107.

In block 1107, a user requests to execute a QUA program on the quantummachine. This may be done via a Quantum Machine API. In an example ofsuch an API, shown in Table 6, this may include a call to the execute( )function. Prior to the request to execute the QUA program, and/or duringthe execution of the QUA program, the user can use a Quantum MachineAPI, such as the one shown below in table 6, to alter any parameter thatwas set in the specification 902. This is advantageous where, forexample, something (e.g., temperature, voltage, equipment in use, and/orany other factor that may impact a quantum experiment), has changedsince the time the specification 902 was generated.

TABLE 6 Quantum Machine API Class QuantumMachine (machine_id, pb_config,config, manager)  close( )  Closes the quantum machine.    Returns   True if the close request succeeded, Raises an exception otherwise. execute(program, duration_limit=1000, data_limit=20000,force_execution=False, dry_run=  False, **kwargs) → qm.QmJob.QmJob  Executes a program and returns a job object to keep track of executionand get results.   Parameters   • program - A program( ) objectgenerated in QUA to execute   • duration_limit (int) - Maximal time (inmsec) for which results will be collected.   • data_limit (int) -   Maximal amount of data sends for which results will be collected.   Here data sends is either:     1. 4 ADC samples, in case raw data istransferred     2. a single save operation   • force_execution (bool) -Execute program even if warnings occur (verify this)   • dry_run(bool) - compile program but do not run it (verify this)   No newresults will be available to the returned job object When duration_limitis reached,   or when data_limit is reached, whichever occurs sooner.  Returns   A QmJob object that can be used to keep track of theexecution and get results  get_config( )    Gives the current config ofthe qm    Returns    A dictionary with the qm's config get_dc_offset_by_qe(qe, input)    get the current DC offset of thequantum control module analog output channel    associated with aquantum element. ** remove ** note: not currently implemented.   Parameters    • qe - the name of the element to get the correctionfor    • input - the input name as appears in the element's config bemore specific here     Returns    the offset, in normalized output units get_digital_buffer(qe, digital input)    get the buffer for digitalwaveforms of the quantum element    Parameters    • qe (str) - the nameof the element to get the buffer for    • digital_input (str) - thedigital input name as appears in the element's config     Returns    thebuffer  get_digital_delay(qe, digital_input)   Parameters   • qe - thename of the element to get the delay for   • digital_input - the digitalinput name as appears in the element's config    Returns   the delay  get_io1_value( )   Gives the data stored in IO1, which is a reservedvariable that refers to a first IO register   in the I/O manager 368.  No inference is made on type.   Returns   A dictionary with datastored in  

 . (Data is in all three format: int, float, bool)  get_io2_value( )   Gives the data stored in IO2, which is a reserved variable thatrefers to a first IO register    in the I/O manager 368    No inferenceis made on type.    Returns    A dictionary with data from the second IOregister. (Data is in all three format: int, float,    and bool) get_io_values( )    Gives the data stored in both IO1 and IO2    Noinference is made on type.    Returns    A list that containsdictionaries with data from the IO registers. (Data is in all three   format: int, float, and bool)  get_smearing(qe)    get the smearingassociated with a measurement quantum element.    This is a broadeningof the raw results acquisition window, to account for dispersive   broadening in the measurement elements (readout resonators etc.) Theacquisition    window will be broadened by this amount on both sides.   Parameters    qe (str) - the name of the element to get smearing for   Returns    the smearing, in nsec.  get_time_of_flight(qe)    get thetime of flight, associated with a measurement quantum element.    Thisis the amount of time between the beginning of a measurement pulseapplied to    quantum element and the time that the data is available tothe controller for    demodulation or streaming.    Parameters    qe(str) - the name of the element to get time of flight for    Returns   the time of flight, in nsec  list_controllers( )    Gives a list withthe defined controllers in this qm    Returns    The names of thecontrollers configured in this qm  save_config_to_file(filename)   Saves the qm current config to a file    Parameters    filename: Thename of the file where the config will be saved  set_correction(qe,values)  Sets the correction matrix for correcting gain and phaseimbalances of an IQ mixer associated  with a quantum element. Parameters  • qe (str) - the name of the element to update thecorrection for  • values (tuple) - 4 value tuple which represents thecorrection matrix  set_dc_offset_by_qe(qe, input, offset)    set thecurrent DC offset of the quantum control module analog output channel   associated with a quantum element.    Parameters    • qe (str) - thename of the element to update the correction for    • input (str) - theinput name as appears in the element config. Options:      ′single′      for an element with single input      ′I′ or ′Q′       for anelement with mixer inputs    • offset (float) - the dc value to set to,in normalized output units. Ranges from −0.5     to 0.5 - 2{circumflexover ( )}-16 in steps of 2{circumflex over ( )}-16. set_digital_buffer(qe, digital_input, buffer)    set the buffer fordigital waveforms of the quantum element    Parameters    • qe (str) -the name of the element to update buffer for    • digital_input(str)-the digital input name as appears in the element's config    •buffer (int) - the buffer value to set to, in nsec. Range: 0 to (255 -delay) / 2, in     steps of 1  set_digital_delay(qe, digital_input,delay)    Sets the delay of the digital waveform of the quantum element   Parameters    • qe (str) - the name of the element to update delayfor    • digital_input (str) - the digital input name as appears in theelement's config    • delay (int) - the delay value to set to, in nsec.Range: 0 to 255 - 2 * buffer, in     steps of 1  set_frequency(qe, freq)   Sets the frequency of an element, at the output of the mixer, takingLO frequency into    account.    Parameters    • qe (str) - the name ofthe element to update the correction for    • freq (float) - thefrequency to set to the given element  set_intermediate_frequency(qe,freq)    Sets the intermediate frequency of the quantum element:   Parameters    • qe (str) - the name of the element to update theintermediate frequency for    • freq (float) - the intermediatefrequency to set to the given element  set_io1_yalue(value_1)    Setsthe value od IO1.    This can be used later inside a QUA program as aQUA variable IO1 without declaration.    The type of QUA variable isinferred from the python type passed to value_1, according    to thefollowing rule:    int -> int float -> fixed bool -> bool    Parameters   value_1 (float | bool | int) - the value to be placed in  

   set_io2_value(value_2)    Sets the value of IO1    This can be usedlater inside a QUA program as a QUA variable IO2 without declaration.   The type of QUA variable is inferred from the python type passed tovalue_2, according    to the following rule:    int -> int float ->fixed bool -> bool    Parameters    value_1 (float | bool | int) - thevalue to be placed in IO1  set_io_values(value_1, value_2)    Sets thevalue of IO1 and IO2    This can be used later inside a QUA program as aQUA variable IO1, IO2 without    declaration. The type of QUA variableis inferred from the python type passed to    value_1, value_2 accordingto the following rule:    int -> int float -> fixed bool -> bool   Parameters    • value_1 (float | bool | int) - the value to be placedin IO1    • value_2 (float | bool | int) - the value to be placed in IO2 set_smearing(qe, smearing)    set the smearing associated with ameasurement quantum element.    This is a broadening of the raw resultsacquisition window, to account for dispersive    broadening in themeasurement elements (readout resonators etc.) The acquisition    windowwill be broadened by this amount on both sides.    Parameters    • qe(str) - the name of the element to set smearing for    • smearing(int) - the time, in nsec, to broaden the acquisition window. Range: 0to     (255 - time of flight)/2, in steps of 1.  set_time_of_flight(qe,time_of_flight)    set the time of flight, associated with a measurementquantum element.    This is the amount of time between the beginning ofa measurement pulse applied to    quantum element and the time that thedata is available to the controller for    demodulation or streaming.   This time also accounts for processing delays, which are typically176nsec.    Parameters    • qe (str) - the name of the element to settime of flight for    • time_of_flight (int) - the time of flight toset, in nsec. Range: 0 to 255 - 2 *     smearing, in steps of 4.

In block 1108, compiler 906 receives the quantum machine specificationand the QUA program (e.g., in the form of two plain text files).

In block 1109, compiler 906 attempts to compile the program using thequantum machine specification and the resources of the quantumcontroller 210 that the quantum machines manager 908 indicates areavailable for program execution. During compilation, the compilerdetermines and allocates the program resources of the quantum controller210 that will be used in the program.

In block 1110, the compiler 906 determines whether compilation issuccessful. If not, then in block 1122 an alert is generated for theuser (e.g., to inform the user that there are currently insufficientresources available to execute the program). If compilation issuccessful, then the process advances to block 1112. If compilation issuccessful the compiler outputs the machine code to be loaded to thequantum controller for program execution.

In block 1112, the programming system 202 loads machine code generatedby the compiler 906 based on the program, the quantum machinespecification, and the available resources into quantum controller 210(e.g., via I/O Manager 368).

In block 1114, the programming subsystem 202 determines whether themachine code has been successfully loaded into the quantum controller210. If not, then in block 1122 an alert is generated for the user. Ifthe machine code is successfully loaded, then the process advances toblock 1116.

In block 1116, the program is executed on the quantum controller and thequantum machines manager 908 updates its data structure of availableresources to reflect the allocation of resources to the program.

Either while the program is executing and/or after the program executionis over, the user may change the configuration/specification of thequantum machine. This may be done via a Quantum Machine API, an exampleimplementation of which is shown in Table 6. An example of changing theconfiguration/specification of the quantum machine may be that the useruses the call to the set_frequency(qe, freq) function, which changes thefrequency of the specified element to the specified frequency. Anotherexample is using the quantum machine API to set the value of an IOregister in the I/O Manager 368. For example, the following showswaiting for a QUA program to reach a pause instruction, then IO1 is setto a new value via the quantum machine API, and then the QUA programresumes.

  job = qm.execute(program) while job.isPaused( ) != True  wait(0.1)qm.set_IO1([new value]) job.resume( )

In another example implementation such quantum machines API may includecommands for changing any parameter defined in the specification (e.g.an API command may allow to change the definition of the samples of aspecified waveform, change the parameters of a neural network associatedwith an element or a pulse, etc.) If the specification is changed whilea program is running on the quantum machine, this may include writing toregisters and/or memory of the quantum controller 210 while the programis executing as well as changing the specification in the quantummachines manager. If the specification is changed while no program isrunning of the quantum machine, this may include only changing thespecification in the quantum machines manager. The ability to altercharacteristics of the quantum machine without closing the quantummachine and even during execution of a QUA program on the quantummachine enables, for example, altering the quantum machine based oncalculations performed on the quantum programming subsystem 202. As anexample, during execution of a QUA program, results may be streamed fromthe quantum controller 210 to the quantum programming subsystem 202, thequantum programming subsystem 202 may perform some calculations usingthe results (e.g., resource-intensive calculations not possible ordesirable to perform on the quantum controller 210) and then update thequantum machine based on the calculations. The update may impact thecurrently running QUA program or a successive run of the same QUAprogram or a different QUA program without having to close the quantummachine for reconfiguration (which may be desirable to, for example,avoid having to repeat a calibration).

In block 1118, upon completing execution of the instructions, theprogram ends and the quantum machines manager 908 updates its datastructure to deallocate the program resources that were allocated tothat program and updates the available resources.

In block 1120, the process can advance either back to block 1107 againin which a user a user requests to execute a QUA program on the quantummachine, or to block 1124 in which a user closes the quantum machine. Ifthe user closes the quantum machine the process advances to block 1126.

In block 1126 the quantum machines manager 908 deallocate the machineresources that were allocated to that quantum machine and updates theavailable resources.

In an example implementation, the pulse generation program 904 iswritten using the QUA programming language.

To aid understanding of the QOP's unique approach to quantum control, ause case example of Power Rabi Calibration will now be described,end-to-end. The use case begins by discussing the theoretical backgroundof the experiment and its goals and showing a typical setup on which itis implemented. It is then shown, step by step, how to program the QOPto perform this experiment, how to execute it, and how to retrieve theresults.

The purpose of Power Rabi Calibration is to measure Rabioscillations—oscillations of the qubit state that are driven by acontrol signal. Assume that the qubit is initially in the ground state(state 0), a drive pulse is applied to rotate the qubit on the Blochsphere around a rotation axis in the x-y plane. The qubit is thenmeasured by calculating the effect of the resonator (that is coupled tothe qubit) on a measurement pulse. The rotation angle, and consequentlythe probability to find the qubit in the excited state (1), depends onthe amplitude of the drive pulse. The protocol is repeated with varyingamplitudes (a). For each amplitude, the protocol is repeated many timesfor averaging, which allows extracting the probability of the qubit tobe in the excited state after the drive pulse is applied. Thisprobability is then plotted as a function of the drive amplitude, fromwhich the rotation angle, as a function of the amplitude, can beextracted. This experiment provides an important tool for calibratingquantum gates. For example, the amplitude at which the qubit reaches arotation of 180 degrees gives us the required amplitude for performingan X-gate (the quantum NOT gate). Similarly, this program can be run toidentify the amplitude required to perform a π/2-rotation.

The example experiment setup is shown in FIG. 12A. The quantum device isa superconducting circuit composed of a single, fixed frequency qubitand a readout resonator, with the following Hamiltonian:

$H = {{\frac{\hslash}{2}\omega_{Q}\sigma_{Z}} + {{\hslash\omega}_{R}a^{+}a} + {{{\hslash g}\left( {{a^{+}\sigma^{-}} + {a\;\sigma^{+}}} \right)}.}}$

Since the interaction between the qubit and resonator is dispersive(|ω_(R)−ω_(Q)|), an approximation can be made that leads to thefollowing form of the Hamiltonian:

$H = {{\frac{\hslash}{2}\left( {\omega_{Q} + \frac{g^{2}}{\Delta}} \right)\sigma_{Z}} + {{\hslash\left( {\omega_{R} + {\frac{g^{2}}{\Delta}\sigma_{Z}}} \right)}a^{+}a}}$

Where Δ=ω_(Q)−ω_(R). Finally, the qubit driving term can be explicitlyincluded, which leads to the Hamiltonian:

$H = {H_{0} + {{{\hslash s}(t)}\sigma_{x}} + {\frac{m(t)}{2}\left\lbrack {{a^{+}e^{{- i}\;\omega\; t}} + {a\; e^{i\;\omega\; t}}} \right\rbrack}}$

Here it is assumed that the frequencies of both the qubit and theresonator were calibrated in advance.

A signal, at the resonance frequency of the qubit, of the form

S(t)=A cos(ω_(Q) t+ϕ)

rotates the Bloch vector of the qubit at a rate A around the axis whichis on the x-y plane and is rotated by an angle φ from the x-axis.

If the parameters A(t) and φ(t) are varied slowly compared to ω_(Q),then this still holds at each point in time. Thus, if a pulse is sent(i.e. a signal that is finite in time) to the qubit of the form

s(t)=A(t)cos(ω_(Q) t+ϕ)

where A(t) varies slowly compared to ω_(Q), the Bloch vector will berotated around the above axis by a total angle which is given by theintegral of A(t):

θ=∫_(t) ₀ ^(t) ⁰ ^(+r) A(t)dt

Here t₀ is the time at which the pulse starts and τ is the duration ofthe pulse.

In a typical Power Rabi Oscillations experiment, the shape and durationof the pulse A(t) are fixed (e.g. a 20-nanosecond gaussian pulse) andonly its amplitude is varied in order to get different rotation anglesθ. The experiment performed by repeating the following basic sequence:

(1) Initialize the qubit to the ground state, 0.(2) Apply a pulse with amplitude a (e.g. A(t) is a Gaussian shaped pulsewith peak amplitude a, which rotates the qubit by θ so that the qubit isin the state

cos(θ_(a))|0

+e ^(iϕ) sin(θ_(a))|1

(3) Apply a resonant pulse to the readout resonator, and from the phaseof the reflected pulse, deduce the state of the qubit.

This basic sequence is repeated in the program for a series ofamplitudes (i.e., many values of a), where for each amplitude, a, it isrepeated N times (i.e. N identical basic sequences with the same a). Nidentical measurements are required because of state collapse. Themeasurement at the end of each basic sequence gives a binary result (0or 1) for the state of the qubit, even if before the measurement thequbit was in a superposition state. However, when the results of the Nidentical basic sequences are averaged, the average will be ˜sin²(θ).Denote this average as

(a) since it reflects the probability of measuring the qubit in the |1

state for a given amplitude, a. The results of the whole experiment canbe summarized by plotting

(a) as a function of a (see FIG. 12B).

This can be used to calibrate any single qubit rotation gate thatrotates the qubit by an angle θ, around a rotation axis that is on thex-y plane and is rotated φ from the x-axis. Such a gate is denoted byR_(ϕ(θ)). In fact, one of the typical goals of the Power RabiOscillations experiment is to calibrate the amplitude of a given pulseso that it performs π-rotation (X-gate) or π/2-rotation. φ, however,cannot be determined from the Rabi oscillations and must be determinedby other means (e.g. tomography).

An example implementation of the Power Rabi experiment in the QOP willnow be described.

The experiment is implemented on the QOP as follows: (1) Defining aquantum machine specification; (2) Opening an interface to the quantummachine; (3) Writing the program; (4) Running the program; (5) Savingthe results

As discussed above, the quantum machine specification is a descriptionof the physical elements present in the experimental setup and theirproperties, as well as the connectivity between the elements and thequantum control module(s). The physical elements that are connected tothe quantum control module(s) are denoted in the quantum machinespecification as elements, which are discrete entities such as qubits,readout resonators, flux lines, gate electrodes, etc. Each of these hasinputs and in some cases outputs, connected to the quantum controlmodule(s). The properties of the elements and their connectivity to thequantum control module(s) are used by the QOP to interpret and executeQUA programs correctly (e.g. a pulse played to a certain qubit ismodulated by the quantum control module with the intermediate frequencydefined for this element). The quantum machine specification in FIGS.10A-10C is used for this particular example.

The pulses applied to the elements are also specified in the quantummachine specification, where each pulse is defined as a collection oftemporal waveforms. For example, a pulse to an element with two analoginputs and one digital input will specify the two waveforms applied tothe analog inputs of the element and the digital pulse applied to itsdigital input.

Also defined in the quantum machine specification are the properties ofany auxiliary components that affect the actual output of thecontroller, such as IQ mixers and local oscillators.

After defining the quantum machine specification, an interface to a newquantum machine can be opened with the following command:

my_qm=qmManager.open_qm(my_config)

After having defined the quantum machine specification, write the QUAprogram. Below is the power Rabi program.

  with program( ) as powerRabiProg :  I = declare(fixed)  Q =declare(fixed)  a = declare(fixed)  Nrep = declare(int)  with for_(Nrep,0, Nrep < 100, Nrep + 1):   with for_(a, 0.00, a <= 1.0, a + 0.01):   play(‘gauss_pulse’*amp(a), ‘qubit’)    align(“qubit”, “RR”)   measure(‘meas_pulse’, ‘RR’, ‘samples’,(‘integW1’,I),    (‘integW2’,Q))    save(I, ‘I’)    save(Q, ‘Q’)    save(a, ‘a’)

The program is very intuitive to someone who knows the theory of thePower Rabi calibration, which illustrates one of the benefits of theQOP: the ability for people (e.g., quantum physicists) to rapidly designand run quantum experiments without first having to become expertprogrammers or computer systems designers. This is in stark contrast tocurrent systems which, for example, require quantum physicists to learna hardware description language such as VHDL or Verilog to be able torun their quantum experiments/algorithms.

This program: (1) Defines the variables a (amplitude) and Nrep (numberof repetitions), as well as the variables I and Q, which store thedemodulation result; and (2) Performs 100 repetitions (the loop overNrep), where in each scan loops over 100 values of a, from 0-1 inincrements of 0.01 and for each value of a performs the Rabi sequence:playing a pulse with amplitude a to the qubit, then measuring theresonator response and extracting from it the state of the qubit. Thisis done by sending a measurement pulse to the resonator and demodulatingand integrating the returning pulse using the indicated integrationweights.

The raw data sampled at the quantum control module's input is alsostreamed and saved with the label ‘samples.’ Finally, the demodulationand integration results, I and Q, are saved as well as the correspondingamplitude.

This Python code block creates an object named powerRabiProg, which is aQUA program that can be executed on an open quantum machine.

The program is run on a quantum machine “my_qm” defined in the quantummachine specification using the following command which saves theresults in the job object “myjob.”

myjob=my_qm.execute(powerRabiProg)

After the program is executed, the results can be pulled:

my_powerRabi_results=job.get_results( )

This command pulls the results from “my_job” to the results object“my_powerRabi_results”.

The data in “my_powerRabi_results” is a Python object which contains thevariables saved during the program, as well as all the raw data sampledat the input of the quantum control module. Here, “my_powerRabi_results”will have: (1) my_powerRabi_results.variable_results, which will be adictionary containing three keys: ‘I’, ‘Q’ and ‘a’. The value for eachkey will be a dictionary containing the saved data and the time stampfor each saved data point; (2) my_powerRabi_results.raw_results, whichwill be a dictionary containing a single key and its value will be adictionary containing the sampled input data and the timestamp of eachdata point.

In accordance with an example implementation of this disclosure, asystem comprises a pulse program compiler circuit (e.g., 906) comprisingcircuitry operable to analyze a pulse program (e.g., 904) that comprisesa pulse operation statement that (e.g., a play or measure statement oftable 1) that specifies a first pulse to be generated, and specifies atarget of the first pulse (e.g., a qubit, antenna, and/or any otherdevice or circuit to or at which pulses are transmitted). The compileris operable to generate, based on the pulse program, machine code that,if loaded into a pulse generation and measurement circuit (e.g., 260),configures the pulse generation and measurement circuit to generate thefirst pulse and send the first pulse to the target. The pulse programmay comprises a first declaration statement that defines a firstvariable, and the pulse operation statement may reference the firstvariable. The first variable may be part of an expression thatdetermines one or more characteristics (e.g., phase, frequency,amplitude, duration, time of generation, and/or the like) of the firstpulse. Loading the machine code into the pulse generation andmeasurement circuit may configure the pulse generation and measurementcircuit to determine (e.g., in a CSP 410) a value to be assigned to thefirst variable during runtime of the machine code. The pulse operationstatement may specify parameters to be used for processing of a returnsignal resulting from transmission of the first pulse (e.g., a returnfrom a readout resonator that was the target of the first pulse or areflection of the first pulse off of a physical object), and loading themachine code into the pulse generation and measurement circuit mayconfigure the pulse generation and measurement circuit to perform theprocessing of the return signal. The processing of the return signal maycomprise integration of the return signal, and the parameters mayspecify integration weights to use for the integration. The integrationweights may be specified as one or more vectors. The parameters maycomprise parameters of a neural network to be used for the processing ofthe return signal. The processing of the return signal may comprisesintegration of the return signal, and the parameters may specify timeparameters to use for the integration (e.g., duration of a window overwhich to perform the integration, a length of an offset of window,and/or the like). The processing of the return signal may comprisedemodulation of the return signal. The parameters may specify thefrequency of a local oscillator to use for the demodulation. The returnsignal may comprise a series of pulses and the processing of the returnsignal may comprise counting the number of pulses in a given timewindow. The return signal may comprises a series of pulses and theprocessing of the return signal may comprise identifying the arrivaltime of each pulse relative to the beginning of a specified time window.The pulse operation statement may specify that a result of processing ofa return signal resulting from transmission of the first pulse is to beassociated with the first variable and stored to memory (e.g., in 260and/or 252), and loading the machine code into the pulse generation andmeasurement circuit may configure the pulse generation and measurementcircuit to associate the result with the first variable and store theresult to memory. The pulse operation statement may specify anexpression to be used for processing of the first pulse by the pulsegeneration and measurement circuit (e.g., in a pulser 302 and/or pulseoperations circuit 358) before the pulse generation and measurementcircuit sends the first pulse to the target. Loading the machine codeinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to perform the processing ofthe first pulse before sending the first pulse to the target. The pulseprogram may comprise a first declaration statement that defines a firstvariable. The pulse operation statement may references the firstvariable. The expression may reference the first variable. Loading themachine code into the pulse generation and measurement circuit mayconfigure the pulse generation and measurement circuit to determine thevalue of the first variable during runtime of the machine code. Thepulse operation statement may specify a condition expression that is tobe evaluated during runtime by the pulse generation and measurementcircuit, and that must evaluate to a determined value before the firstpulse is sent to the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to evaluate the condition expression duringruntime of the machine code, and send the first pulse to the target onlywhen the condition expression evaluates to the determined value. Thepulse program comprises a phase alteration statement that specifies thetarget and an expression for the angle by which to alter a phase of alocal oscillator of the pulse generation and measurement circuit that isassociated with the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to evaluate the expression during runtime of themachine code, and alter the phase of the local oscillator generationcircuit based on a result of the evaluation of the expression. The pulseprogram may comprises a update frequency statement that specifies thetarget and an expression for the frequency to which to set a localoscillator of the pulse generation and measurement circuit that isassociated with the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to: evaluate the expression during runtime ofthe machine code; and set the frequency of the local oscillatorgeneration circuit based on a result of the evaluation of theexpression. The pulse program may comprises a flow control statement(e.g., a trigger wait, a wait or wait_for_trigger statement). Thetrigger wait statement is able to stop the program execution until atrigger is received. Such a trigger may be generated by software orhardware. Loading the machine code comprising the flow control statementinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to wait for a signal beforeresuming execution of the pulse program. The pulse program comprises aconditional statement (e.g., if statement, loop statement, etc.) thatspecifies a condition expression and one or more conditioned statements.Loading the machine code into the pulse generation and measurementcircuit may configure the pulse generation and measurement circuit to:evaluate the condition expression; and execute instructionscorresponding to the one or more condition statements only if thecondition expression evaluates to a determined value (e.g., true orfalse). The compiler may be operable to parse a machine specification(e.g., 902) that comprises a definition of the first pulse and adefinition of the target; and generate the machine code based on theparsed machine specification. The pulse operation statement mayspecifies a break condition. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to: evaluate the break condition expression; andstop generation of the first pulse when the break condition evaluates toa determined value. The pulse program may comprise an align statementthat specifies a plurality of pulse targets. Loading the machine codeinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to wait for execution ofinstructions involving any of the plurality of pulse targets to completebefore beginning execution of subsequent instructions involving any ofthe plurality of pulse targets. The pulse program may comprises a waitstatement that specifies a target and an amount of time to wait beforesending a pulse to the target. Loading the machine code into the pulsegeneration and measurement circuit may configures the pulse generationand measurement circuit to wait the specified amount of time. The pulseprogram may comprise a variable assignment statement that assigns anexpression to a variable (e.g., 101) that is associated with a registerthat can be read from and/or written to by a programming subsystemduring runtime of the machine code, and the pulse operation statementmay references the variable (e.g., as a parameter and/or in anexpression). The pulse program may comprise a variable declarationstatement that assigns a first variable to a second variable, where thesecond variable (e.g., 101) is a reserved variable reference to aregister that can be read from and/or written to by a programmingsubsystem during runtime of the machine code, and the pulse operationstatement may references the second variable.

The present method and/or system may be realized in hardware, software,or a combination of hardware and software. The present methods and/orsystems may be realized in a centralized fashion in at least onecomputing system, or in a distributed fashion where different elementsare spread across several interconnected computing systems. Any kind ofcomputing system or other apparatus adapted for carrying out the methodsdescribed herein is suited. A typical implementation may comprise one ormore application specific integrated circuit (ASIC), one or more fieldprogrammable gate array (FPGA), and/or one or more processor (e.g., x86,x64, ARM, PIC, and/or any other suitable processor architecture) andassociated supporting circuitry (e.g., storage, DRAM, FLASH, businterface circuits, etc.). Each discrete ASIC, FPGA, Processor, or othercircuit may be referred to as “chip,” and multiple such circuits may bereferred to as a “chipset.” Another implementation may comprise anon-transitory machine-readable (e.g., computer readable) medium (e.g.,FLASH drive, optical disk, magnetic storage disk, or the like) havingstored thereon one or more lines of code that, when executed by amachine, cause the machine to perform processes as described in thisdisclosure. Another implementation may comprise a non-transitorymachine-readable (e.g., computer readable) medium (e.g., FLASH drive,optical disk, magnetic storage disk, or the like) having stored thereonone or more lines of code that, when executed by a machine, cause themachine to be configured (e.g., to load software and/or firmware intoits circuits) to operate as a system described in this disclosure.

As used herein the terms “circuits” and “circuitry” refer to physicalelectronic components (i.e. hardware) and any software and/or firmware(“code”) which may configure the hardware, be executed by the hardware,and or otherwise be associated with the hardware. As used herein, forexample, a particular processor and memory may comprise a first“circuit” when executing a first one or more lines of code and maycomprise a second “circuit” when executing a second one or more lines ofcode. As used herein, “and/or” means any one or more of the items in thelist joined by “and/or”. As an example, “x and/or y” means any elementof the three-element set {(x), (y), (x, y)}. As another example, “x, y,and/or z” means any element of the seven-element set {(x), (y), (z), (x,y), (x, z), (y, z), (x, y, z)}. As used herein, the term “exemplary”means serving as a non-limiting example, instance, or illustration. Asused herein, the terms “e.g.,” and “for example” set off lists of one ormore non-limiting examples, instances, or illustrations. As used herein,circuitry is “operable” to perform a function whenever the circuitrycomprises the necessary hardware and code (if any is necessary) toperform the function, regardless of whether performance of the functionis disabled or not enabled (e.g., by a user-configurable setting,factory trim, etc.). As used herein, the term “based on” means “based atleast in part on.” For example, “x based on y” means that “x” is basedat least in part on “y” (and may also be based on z, for example).

While the present method and/or system has been described with referenceto certain implementations, it will be understood by those skilled inthe art that various changes may be made and equivalents may besubstituted without departing from the scope of the present methodand/or system. In addition, many modifications may be made to adapt aparticular situation or material to the teachings of the presentdisclosure without departing from its scope. Therefore, it is intendedthat the present method and/or system not be limited to the particularimplementations disclosed, but that the present method and/or systemwill include all implementations falling within the scope of theappended claims.

What is claimed is:
 1. A system comprising: a pulse program compilercircuit operable to: analyze a pulse program that comprises: a pulseoperation statement that: specifies a first pulse to be generated;determines a characteristic of the first pulse; and specifies a targetof the first pulse; and generate, based on the pulse program, machinecode that, if loaded into a pulse generation and measurement circuit,configures the pulse generation and measurement circuit to generate thefirst pulse and send the first pulse to the target.
 2. The system ofclaim 1, wherein: the pulse program comprises a first declarationstatement that defines a first variable; and the pulse operationstatement references the first variable.
 3. The system of claim 2,wherein the first variable is part of an expression that determines thecharacteristic of the first pulse.
 4. The system of claim 1, wherein thecharacteristic is an amplitude of the first pulse.
 5. The system ofclaim 1, wherein the characteristic is a duration of the first pulse. 6.The system of claim 3, wherein the machine code, if loaded into thepulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to determine a value to be assignedto the first variable during runtime of the machine code.
 7. The systemof claim 1, wherein: the pulse operation statement does not specify anintermediate frequency of the first pulse; and the compiler circuit isoperable to, during generation of the machine code, set the intermediatefrequency of the first pulse based on the target.
 8. The system of claim1, wherein: the pulse operation statement specifies parameters to beused for processing of a return signal resulting from transmission ofthe first pulse; and the machine code, if loaded into the pulsegeneration and measurement circuit, configures the pulse generation andmeasurement circuit to perform the processing of the return signal. 9.The system of claim 8, wherein: the processing of the return signalcomprises integration of the return signal; and the parameters specifyintegration weights to use for the integration.
 10. The system of claim9, wherein the integration weights are specified as one or more vectors.11. The system of claim 8, wherein the parameters comprise parameters ofa neural network to be used for the processing of the return signal. 12.The system of claim 8, wherein: the processing of the return signalcomprises integration of the return signal; and the parameters specifytime parameters to use for the integration.
 13. The system of claim 8,wherein: the processing of the return signal comprises demodulation ofthe return signal; and the parameters specify a frequency to use for thedemodulation.
 14. The system of claim 8, wherein: the return signalcomprises a series of pulses and the processing of the return signalcomprises counting a number of pulses in a given time window.
 15. Thesystem of claim 8, wherein: the return signal comprises a series ofpulses and the processing of the return signal comprises identifying anarrival time of each pulse relative to a beginning of a specified timewindow.
 16. The system of claim 1, wherein: the pulse program comprisesa first declaration statement that defines a first variable; the pulseoperation statement references the first variable; the pulse operationstatement specifies that a result of processing of a return signalresulting from transmission of the first pulse is to be associated withthe first variable and stored to memory; and the machine code, if loadedinto the pulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to associate the result with thefirst variable and store the result to memory.
 17. The system of claim1, wherein: the pulse operation statement specifies an expression to beused for processing of the first pulse by the pulse generation andmeasurement circuit before the pulse generation and measurement circuitsends the first pulse to the target; and the machine code, if loadedinto the pulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to perform the processing of thefirst pulse before sending the first pulse to the target.
 18. The systemof claim 17, wherein: the pulse program comprises a first declarationstatement that defines a first variable; the expression references thefirst variable; and the machine code, if loaded into the pulsegeneration and measurement circuit, configures the pulse generation andmeasurement circuit to determine a value of the first variable duringruntime of the machine code.
 19. The system of claim 18, wherein themachine code, if loaded into the pulse generation and measurementcircuit, configures the pulse generation and measurement circuit toprocess a return signal and determine a value of the first variablebased on the processing of the return signal.
 20. The system of claim19, wherein the value of the first variable is a fixed point or floatingpoint number.
 21. The system of claim 1, wherein: the pulse operationstatement specifies a condition expression that: is to be evaluatedduring runtime by the pulse generation and measurement circuit; and mustevaluate to a determined value before the first pulse is sent to thetarget; and the machine code, if loaded into the pulse generation andmeasurement circuit, configures the pulse generation and measurementcircuit to: evaluate the condition expression during runtime of themachine code; and send the first pulse to the target only when thecondition expression evaluates to the determined value.
 22. The systemof claim 1, wherein: the pulse program comprises a phase alterationstatement that specifies the target and an expression for an angle bywhich to alter a phase of a local oscillator of the pulse generation andmeasurement circuit that is associated with the target; and the machinecode, if loaded into the pulse generation and measurement circuit,configures the pulse generation and measurement circuit to: evaluate theexpression during runtime of the machine code; and alter the phase ofthe local oscillator generation circuit based on a result of theevaluation of the expression.
 23. The system of claim 1, wherein: thepulse program comprises an update frequency statement that specifies thetarget and an expression for the frequency to which to set a localoscillator of the pulse generation and measurement circuit that isassociated with the target; and the machine code, if loaded into thepulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to: evaluate the expression duringruntime of the machine code; and set the frequency of the localoscillator generation circuit based on a result of the evaluation of theexpression.
 24. The system of claim 1, wherein: the pulse programcomprises a flow control statement; and the machine code, if loaded intothe pulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to wait for a signal before resumingexecution of the pulse program.
 25. The system of claim 1, wherein: thepulse program comprises a conditional statement that specifies acondition expression and one or more conditioned statements; and themachine code, if loaded into the pulse generation and measurementcircuit, configures the pulse generation and measurement circuit to:evaluate the condition expression; and execute instructionscorresponding to the one or more conditioned statements only if thecondition expression evaluates to a determined value.
 26. The system ofclaim 25, wherein: the conditioned expression comprises a variable; andthe machine code, if loaded into the pulse generation and measurementcircuit, configures the pulse generation and measurement circuit toprocess a return signal and determine a value of the variable based onthe processing of the return signal.
 27. The system of claim 26, whereinthe value of the variable is a fixed point or floating point number. 28.The system of claim 1, wherein: the pulse program comprises aconditional statement that specifies a condition expression, a firstconditioned statement, and a second conditioned statement; and themachine code, if loaded into the pulse generation and measurementcircuit, configures the pulse generation and measurement circuit to:evaluate the condition expression; and execute instructionscorresponding to the first conditioned statements only if the conditionexpression evaluates to a first value, and execute instructionscorresponding to the second conditioned statement only if the conditionexpression evaluates to a second value.
 29. The system of claim 28,wherein the first conditioned statement is a second pulse operationstatement and the second conditioned statement is a third pulseoperation statement.
 30. The system of claim 1, wherein the pulseprogram compiler circuit is operable to: parse a machine specificationthat comprises a definition of the first pulse and a definition of thetarget; and generate the machine code based on the machinespecification.
 31. The system of claim 1, wherein: the pulse operationstatement specifies a break condition; and the machine code, if loadedinto the pulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to: evaluate the break condition; andstop generation of the first pulse when the break condition evaluates toa determined value.
 32. The system of claim 1, wherein: the pulseprogram comprises an align statement that specifies a plurality of pulsetargets; and the machine code, if loaded into the pulse generation andmeasurement circuit, configures the pulse generation and measurementcircuit to wait for execution of instructions involving any of theplurality of pulse targets to complete before beginning execution ofsubsequent instructions involving any of the plurality of pulse targets.33. The system of claim 1, wherein: the pulse program comprises a waitstatement that specifies a target and an amount of time to wait beforesending a pulse to the target; and the machine code, if loaded into thepulse generation and measurement circuit, configures the pulsegeneration and measurement circuit to wait the specified amount of time.34. The system of claim 1, wherein: the pulse program comprises avariable assignment statement that assigns an expression to a variablethat is associated with a register that can be read from and/or writtento by a programming subsystem during runtime of the machine code; thepulse operation statement references the variable.
 35. The system ofclaim 1, wherein: the pulse program comprises a variable declarationstatement that assigns a first variable to a second variable, where thesecond variable is a reserved variable reference to a register that canbe read from and/or written to by a programming subsystem during runtimeof the machine code; and the pulse operation statement references thesecond variable.
 36. The system of claim 1, wherein the characteristicis a slope of the first pulse.
 37. The system of claim 1, wherein thecharacteristic is a chirp rate of the first pulse.
 38. The system ofclaim 1, wherein the pulse program comprises a trigger wait statementoperable to stop the program execution until a trigger is received. 39.The system of claim 38, wherein the trigger is generated by software.40. The system of claim 38, wherein the trigger is generated byhardware.